if self.info_dc is None:
res = self.ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["*"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
BindTests.info_dc = res[0]
# cache some of RootDSE props
self.schema_dn = self.info_dc["schemaNamingContext"][0]
ldb_res = self.ldb.search(base=self.domain_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % self.username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_dn = ldb_res[0]["dn"]
self.addCleanup(delete_force, self.ldb, user_dn)
ldb_res = self.ldb.search(base=self.domain_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % self.username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_dn = ldb_res[0]["dn"]
self.addCleanup(delete_force, self.ldb, user_dn)
class NormaliseSignatureTests(TestCase):
def test_function_simple(self):
- self.assertEquals("int (const struct GUID *, const struct GUID *)",
+ self.assertEqual("int (const struct GUID *, const struct GUID *)",
normalise_signature("$2 = {int (const struct GUID *, const struct GUID *)} 0xe871 <GUID_compare>"))
def test_maps_Bool(self):
# Some types have different internal names
- self.assertEquals("bool (const struct GUID *)",
+ self.assertEqual("bool (const struct GUID *)",
normalise_signature("$1 = {_Bool (const struct GUID *)} 0xe75b <GUID_all_zero>"))
def test_function_keep(self):
- self.assertEquals(
+ self.assertEqual(
"enum ndr_err_code (struct ndr_push *, int, const union winreg_Data *)",
normalise_signature("enum ndr_err_code (struct ndr_push *, int, const union winreg_Data *)"))
def test_struct_constant(self):
- self.assertEquals(
+ self.assertEqual(
'uuid = {time_low = 0, time_mid = 0, time_hi_and_version = 0, clock_seq = "\\000", node = "\\000\\000\\000\\000\\000"}, if_version = 0',
normalise_signature('$239 = {uuid = {time_low = 0, time_mid = 0, time_hi_and_version = 0, clock_seq = "\\000", node = "\\000\\000\\000\\000\\000"}, if_version = 0}'))
def test_incomplete_sequence(self):
# Newer versions of gdb insert these incomplete sequence elements
- self.assertEquals(
+ self.assertEqual(
'uuid = {time_low = 2324192516, time_mid = 7403, time_hi_and_version = 4553, clock_seq = "\\237\\350", node = "\\b\\000+\\020H`"}, if_version = 2',
normalise_signature('$244 = {uuid = {time_low = 2324192516, time_mid = 7403, time_hi_and_version = 4553, clock_seq = "\\237", <incomplete sequence \\350>, node = "\\b\\000+\\020H`"}, if_version = 2}'))
- self.assertEquals(
+ self.assertEqual(
'uuid = {time_low = 2324192516, time_mid = 7403, time_hi_and_version = 4553, clock_seq = "\\237\\350", node = "\\b\\000+\\020H`"}, if_version = 2',
normalise_signature('$244 = {uuid = {time_low = 2324192516, time_mid = 7403, time_hi_and_version = 4553, clock_seq = "\\237\\350", node = "\\b\\000+\\020H`"}, if_version = 2}'))
abi_write_vscript(f, "MYLIB", "1.0", [], {
"old": "1.0",
"new": "1.0"}, ["*"])
- self.assertEquals(f.getvalue(), """\
+ self.assertEqual(f.getvalue(), """\
1.0 {
\tglobal:
\t\t*;
abi_write_vscript(f, "MYLIB", "1.0", ["0.1"], {
"old": "0.1",
"new": "1.0"}, ["*"])
- self.assertEquals(f.getvalue(), """\
+ self.assertEqual(f.getvalue(), """\
MYLIB_0.1 {
\tglobal:
\t\told;
"exc_old": "0.1",
"old": "0.1",
"new": "1.0"}, ["!exc_*"])
- self.assertEquals(f.getvalue(), """\
+ self.assertEqual(f.getvalue(), """\
1.0 {
\tglobal:
\t\t*;
"exc_bar": "1.0",
"other": "1.0"
}, ["pub_*", "!exc_*"])
- self.assertEquals(f.getvalue(), """\
+ self.assertEqual(f.getvalue(), """\
1.0 {
\tglobal:
\t\tpub_*;
class TuplizeVersionTests(TestCase):
def test_simple(self):
- self.assertEquals((1, 2, 10), tuplize_version("1.2.10"))
+ self.assertEqual((1, 2, 10), tuplize_version("1.2.10"))
class ToListTests(TestCase):
def test_none(self):
- self.assertEquals([], TO_LIST(None))
+ self.assertEqual([], TO_LIST(None))
def test_already_list(self):
- self.assertEquals(["foo", "bar", 1], TO_LIST(["foo", "bar", 1]))
+ self.assertEqual(["foo", "bar", 1], TO_LIST(["foo", "bar", 1]))
def test_default_delimiter(self):
- self.assertEquals(["foo", "bar"], TO_LIST("foo bar"))
- self.assertEquals(["foo", "bar"], TO_LIST(" foo bar "))
- self.assertEquals(["foo ", "bar"], TO_LIST(" \"foo \" bar "))
+ self.assertEqual(["foo", "bar"], TO_LIST("foo bar"))
+ self.assertEqual(["foo", "bar"], TO_LIST(" foo bar "))
+ self.assertEqual(["foo ", "bar"], TO_LIST(" \"foo \" bar "))
def test_delimiter(self):
- self.assertEquals(["foo", "bar"], TO_LIST("foo,bar", ","))
- self.assertEquals([" foo", "bar "], TO_LIST(" foo,bar ", ","))
- self.assertEquals([" \" foo\"", " bar "], TO_LIST(" \" foo\", bar ", ","))
+ self.assertEqual(["foo", "bar"], TO_LIST("foo,bar", ","))
+ self.assertEqual([" foo", "bar "], TO_LIST(" foo,bar ", ","))
+ self.assertEqual([" \" foo\"", " bar "], TO_LIST(" \" foo\", bar ", ","))
class UniqueListTests(TestCase):
def test_unique_list(self):
- self.assertEquals(["foo", "bar"], unique_list(["foo", "bar", "foo"]))
+ self.assertEqual(["foo", "bar"], unique_list(["foo", "bar", "foo"]))
class SubstVarsErrorTests(TestCase):
def test_valid(self):
- self.assertEquals("", subst_vars_error("", {}))
- self.assertEquals("FOO bar", subst_vars_error("${F} bar", {"F": "FOO"}))
+ self.assertEqual("", subst_vars_error("", {}))
+ self.assertEqual("FOO bar", subst_vars_error("${F} bar", {"F": "FOO"}))
def test_invalid(self):
self.assertRaises(KeyError, subst_vars_error, "${F}", {})
def test_empty(self):
ret = {}
dict_concat(ret, {})
- self.assertEquals({}, ret)
+ self.assertEqual({}, ret)
def test_same(self):
ret = {"foo": "bar"}
dict_concat(ret, {"foo": "bla"})
- self.assertEquals({"foo": "bar"}, ret)
+ self.assertEqual({"foo": "bar"}, ret)
def test_simple(self):
ret = {"foo": "bar"}
dict_concat(ret, {"blie": "bla"})
- self.assertEquals({"foo": "bar", "blie": "bla"}, ret)
+ self.assertEqual({"foo": "bar", "blie": "bla"}, ret)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="memberOf=cn=g1,%s" % self.ou_groups)
- self.assertEquals(len(res1), 2)
+ self.assertEqual(len(res1), 2)
dn_list = [str(res.dn) for res in res1]
self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="memberOf:1.2.840.113556.1.4.1941:=cn=g1,%s" % self.ou_groups)
- self.assertEquals(len(res1), 6)
+ self.assertEqual(len(res1), 6)
dn_list = [str(res.dn) for res in res1]
self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="member=cn=g1,%s" % self.ou_groups)
- self.assertEquals(len(res1), 0)
+ self.assertEqual(len(res1), 0)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="member:1.2.840.113556.1.4.1941:=cn=g1,%s" % self.ou_groups)
- self.assertEquals(len(res1), 0)
+ self.assertEqual(len(res1), 0)
def test_g2_members(self):
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="memberOf=cn=g2,%s" % self.ou_groups)
- self.assertEquals(len(res1), 2)
+ self.assertEqual(len(res1), 2)
dn_list = [str(res.dn) for res in res1]
self.assertTrue("CN=g3,%s" % self.ou_groups in dn_list)
self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="memberOf:1.2.840.113556.1.4.1941:=cn=g2,%s" % self.ou_groups)
- self.assertEquals(len(res1), 5)
+ self.assertEqual(len(res1), 5)
dn_list = [str(res.dn) for res in res1]
self.assertTrue("CN=u2,%s" % self.ou_users in dn_list)
self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="member=cn=g2,%s" % self.ou_groups)
- self.assertEquals(len(res1), 1)
- self.assertEquals(str(res1[0].dn), "CN=g1,%s" % self.ou_groups)
+ self.assertEqual(len(res1), 1)
+ self.assertEqual(str(res1[0].dn), "CN=g1,%s" % self.ou_groups)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="member:1.2.840.113556.1.4.1941:=cn=g2,%s" % self.ou_groups)
- self.assertEquals(len(res1), 1)
- self.assertEquals(str(res1[0].dn), "CN=g1,%s" % self.ou_groups)
+ self.assertEqual(len(res1), 1)
+ self.assertEqual(str(res1[0].dn), "CN=g1,%s" % self.ou_groups)
def test_g3_members(self):
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="memberOf=cn=g3,%s" % self.ou_groups)
- self.assertEquals(len(res1), 2)
+ self.assertEqual(len(res1), 2)
dn_list = [str(res.dn) for res in res1]
self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
self.assertTrue("CN=c3,%s" % self.ou_computers in dn_list)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="memberOf:1.2.840.113556.1.4.1941:=cn=g3,%s" % self.ou_groups)
- self.assertEquals(len(res1), 3)
+ self.assertEqual(len(res1), 3)
dn_list = [str(res.dn) for res in res1]
self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
self.assertTrue("CN=c1,%s" % self.ou_computers in dn_list)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="member=cn=g3,%s" % self.ou_groups)
- self.assertEquals(len(res1), 1)
- self.assertEquals(str(res1[0].dn), "CN=g2,%s" % self.ou_groups)
+ self.assertEqual(len(res1), 1)
+ self.assertEqual(str(res1[0].dn), "CN=g2,%s" % self.ou_groups)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="member:1.2.840.113556.1.4.1941:=cn=g3,%s" % self.ou_groups)
- self.assertEquals(len(res1), 2)
+ self.assertEqual(len(res1), 2)
dn_list = [str(res.dn) for res in res1]
self.assertTrue("CN=g1,%s" % self.ou_groups in dn_list)
self.assertTrue("CN=g2,%s" % self.ou_groups in dn_list)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="memberOf=cn=g4,%s" % self.ou_groups)
- self.assertEquals(len(res1), 3)
+ self.assertEqual(len(res1), 3)
dn_list = [str(res.dn) for res in res1]
self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="memberOf:1.2.840.113556.1.4.1941:=cn=g4,%s" % self.ou_groups)
- self.assertEquals(len(res1), 4)
+ self.assertEqual(len(res1), 4)
dn_list = [str(res.dn) for res in res1]
self.assertTrue("CN=u3,%s" % self.ou_users in dn_list)
self.assertTrue("CN=u4,%s" % self.ou_users in dn_list)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="member=cn=g4,%s" % self.ou_groups)
- self.assertEquals(len(res1), 0)
+ self.assertEqual(len(res1), 0)
res1 = self.ldb.search(self.ou,
scope=SCOPE_SUBTREE,
expression="member:1.2.840.113556.1.4.1941:=cn=g4,%s" % self.ou_groups)
- self.assertEquals(len(res1), 0)
+ self.assertEqual(len(res1), 0)
def test_u1_members(self):
res1 = self.ldb.search(self.ou,
def _remove_tempdir(self):
# Note asserting here is treated as an error rather than a test failure
- self.assertEquals([], os.listdir(self.tempdir))
+ self.assertEqual([], os.listdir(self.tempdir))
os.rmdir(self.tempdir)
self.tempdir = None
messages = self.waitForMessages(1, net, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["dsdbChange"]
- self.assertEquals("Modify", audit["operation"])
+ self.assertEqual("Modify", audit["operation"])
self.assertFalse(audit["performedAsSystem"])
self.assertTrue(dn.lower(), audit["dn"].lower())
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
# We skip the check for self.get_service_description() as this
# is subject to a race between smbd and the s4 rpc_server code
# as to which will set the description as it is DCE/RPC over SMB
self.assertTrue(self.is_guid(audit["transactionId"]))
attributes = audit["attributes"]
- self.assertEquals(1, len(attributes))
+ self.assertEqual(1, len(attributes))
actions = attributes["clearTextPassword"]["actions"]
- self.assertEquals(1, len(actions))
+ self.assertEqual(1, len(actions))
self.assertTrue(actions[0]["redacted"])
- self.assertEquals("replace", actions[0]["action"])
+ self.assertEqual("replace", actions[0]["action"])
def test_net_set_password(self):
domain_name=domain)
messages = self.waitForMessages(1, net, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["dsdbChange"]
- self.assertEquals("Modify", audit["operation"])
+ self.assertEqual("Modify", audit["operation"])
self.assertFalse(audit["performedAsSystem"])
- self.assertEquals(dn, audit["dn"])
+ self.assertEqual(dn, audit["dn"])
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
# We skip the check for self.get_service_description() as this
# is subject to a race between smbd and the s4 rpc_server code
# as to which will set the description as it is DCE/RPC over SMB
self.assertTrue(self.is_guid(audit["transactionId"]))
attributes = audit["attributes"]
- self.assertEquals(1, len(attributes))
+ self.assertEqual(1, len(attributes))
actions = attributes["clearTextPassword"]["actions"]
- self.assertEquals(1, len(actions))
+ self.assertEqual(1, len(actions))
self.assertTrue(actions[0]["redacted"])
- self.assertEquals("replace", actions[0]["action"])
+ self.assertEqual("replace", actions[0]["action"])
def test_ldap_change_password(self):
messages = self.waitForMessages(1)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["dsdbChange"]
- self.assertEquals("Modify", audit["operation"])
+ self.assertEqual("Modify", audit["operation"])
self.assertFalse(audit["performedAsSystem"])
- self.assertEquals(dn, audit["dn"])
+ self.assertEqual(dn, audit["dn"])
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
attributes = audit["attributes"]
- self.assertEquals(1, len(attributes))
+ self.assertEqual(1, len(attributes))
actions = attributes["userPassword"]["actions"]
- self.assertEquals(2, len(actions))
+ self.assertEqual(2, len(actions))
self.assertTrue(actions[0]["redacted"])
- self.assertEquals("delete", actions[0]["action"])
+ self.assertEqual("delete", actions[0]["action"])
self.assertTrue(actions[1]["redacted"])
- self.assertEquals("add", actions[1]["action"])
+ self.assertEqual("add", actions[1]["action"])
def test_ldap_replace_password(self):
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["dsdbChange"]
- self.assertEquals("Modify", audit["operation"])
+ self.assertEqual("Modify", audit["operation"])
self.assertFalse(audit["performedAsSystem"])
self.assertTrue(dn.lower(), audit["dn"].lower())
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
self.assertTrue(self.is_guid(audit["transactionId"]))
attributes = audit["attributes"]
- self.assertEquals(1, len(attributes))
+ self.assertEqual(1, len(attributes))
actions = attributes["userPassword"]["actions"]
- self.assertEquals(1, len(actions))
+ self.assertEqual(1, len(actions))
self.assertTrue(actions[0]["redacted"])
- self.assertEquals("replace", actions[0]["action"])
+ self.assertEqual("replace", actions[0]["action"])
def test_ldap_add_user(self):
dn = "cn=" + USER_NAME + ",cn=users," + self.base_dn
messages = self.waitForMessages(2, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(2,
+ self.assertEqual(2,
len(messages),
"Did not receive the expected number of messages")
audit = messages[1]["dsdbChange"]
- self.assertEquals("Add", audit["operation"])
+ self.assertEqual("Add", audit["operation"])
self.assertFalse(audit["performedAsSystem"])
- self.assertEquals(dn, audit["dn"])
+ self.assertEqual(dn, audit["dn"])
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
self.assertTrue(self.is_guid(audit["sessionId"]))
self.assertTrue(self.is_guid(audit["transactionId"]))
attributes = audit["attributes"]
- self.assertEquals(3, len(attributes))
+ self.assertEqual(3, len(attributes))
actions = attributes["objectclass"]["actions"]
- self.assertEquals(1, len(actions))
- self.assertEquals("add", actions[0]["action"])
- self.assertEquals(1, len(actions[0]["values"]))
- self.assertEquals("user", actions[0]["values"][0]["value"])
+ self.assertEqual(1, len(actions))
+ self.assertEqual("add", actions[0]["action"])
+ self.assertEqual(1, len(actions[0]["values"]))
+ self.assertEqual("user", actions[0]["values"][0]["value"])
actions = attributes["sAMAccountName"]["actions"]
- self.assertEquals(1, len(actions))
- self.assertEquals("add", actions[0]["action"])
- self.assertEquals(1, len(actions[0]["values"]))
- self.assertEquals(USER_NAME, actions[0]["values"][0]["value"])
+ self.assertEqual(1, len(actions))
+ self.assertEqual("add", actions[0]["action"])
+ self.assertEqual(1, len(actions[0]["values"]))
+ self.assertEqual(USER_NAME, actions[0]["values"][0]["value"])
actions = attributes["userPassword"]["actions"]
- self.assertEquals(1, len(actions))
- self.assertEquals("add", actions[0]["action"])
+ self.assertEqual(1, len(actions))
+ self.assertEqual("add", actions[0]["action"])
self.assertTrue(actions[0]["redacted"])
def test_samdb_delete_user(self):
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["dsdbChange"]
- self.assertEquals("Delete", audit["operation"])
+ self.assertEqual("Delete", audit["operation"])
self.assertFalse(audit["performedAsSystem"])
self.assertTrue(dn.lower(), audit["dn"].lower())
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
- self.assertEquals(0, audit["statusCode"])
- self.assertEquals("Success", audit["status"])
+ self.assertEqual(0, audit["statusCode"])
+ self.assertEqual("Success", audit["status"])
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
transactionId = audit["transactionId"]
message = self.waitForTransaction(transactionId)
audit = message["dsdbTransaction"]
- self.assertEquals("commit", audit["action"])
+ self.assertEqual("commit", audit["action"])
self.assertTrue(self.is_guid(audit["transactionId"]))
self.assertTrue(audit["duration"] > 0)
messages = self.waitForMessages(1)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["dsdbChange"]
- self.assertEquals("Delete", audit["operation"])
+ self.assertEqual("Delete", audit["operation"])
self.assertFalse(audit["performedAsSystem"])
self.assertTrue(dn.lower(), audit["dn"].lower())
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
- self.assertEquals(ERR_NO_SUCH_OBJECT, audit["statusCode"])
- self.assertEquals("No such object", audit["status"])
+ self.assertEqual(ERR_NO_SUCH_OBJECT, audit["statusCode"])
+ self.assertEqual("No such object", audit["status"])
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
transactionId = audit["transactionId"]
message = self.waitForTransaction(transactionId)
audit = message["dsdbTransaction"]
- self.assertEquals("rollback", audit["action"])
+ self.assertEqual("rollback", audit["action"])
self.assertTrue(self.is_guid(audit["transactionId"]))
self.assertTrue(audit["duration"] > 0)
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["dsdbChange"]
- self.assertEquals("Add", audit["operation"])
+ self.assertEqual("Add", audit["operation"])
self.assertTrue(audit["performedAsSystem"])
self.assertTrue(dn.lower(), audit["dn"].lower())
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
# We skip the check for self.get_service_description() as this
# is subject to a race between smbd and the s4 rpc_server code
# as to which will set the description as it is DCE/RPC over SMB
attributes = audit["attributes"]
- self.assertEquals(2, len(attributes))
+ self.assertEqual(2, len(attributes))
object_class = attributes["objectClass"]
- self.assertEquals(1, len(object_class["actions"]))
+ self.assertEqual(1, len(object_class["actions"]))
action = object_class["actions"][0]
- self.assertEquals("add", action["action"])
+ self.assertEqual("add", action["action"])
values = action["values"]
- self.assertEquals(1, len(values))
- self.assertEquals("secret", values[0]["value"])
+ self.assertEqual(1, len(values))
+ self.assertEqual("secret", values[0]["value"])
cn = attributes["cn"]
- self.assertEquals(1, len(cn["actions"]))
+ self.assertEqual(1, len(cn["actions"]))
action = cn["actions"][0]
- self.assertEquals("add", action["action"])
+ self.assertEqual("add", action["action"])
values = action["values"]
- self.assertEquals(1, len(values))
- self.assertEquals("Test Secret", values[0]["value"])
+ self.assertEqual(1, len(values))
+ self.assertEqual("Test Secret", values[0]["value"])
#
# Now delete the secret.
lsa_conn.DeleteObject(h)
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
dn = "cn=Test Secret,CN=System," + self.base_dn
audit = messages[0]["dsdbChange"]
- self.assertEquals("Delete", audit["operation"])
+ self.assertEqual("Delete", audit["operation"])
self.assertTrue(audit["performedAsSystem"])
self.assertTrue(dn.lower(), audit["dn"].lower())
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
# We skip the check for self.get_service_description() as this
# is subject to a race between smbd and the s4 rpc_server code
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["dsdbChange"]
- self.assertEquals("Modify", audit["operation"])
+ self.assertEqual("Modify", audit["operation"])
self.assertFalse(audit["performedAsSystem"])
- self.assertEquals(dn, audit["dn"])
+ self.assertEqual(dn, audit["dn"])
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
attributes = audit["attributes"]
- self.assertEquals(1, len(attributes))
+ self.assertEqual(1, len(attributes))
actions = attributes["carLicense"]["actions"]
- self.assertEquals(1, len(actions))
- self.assertEquals("add", actions[0]["action"])
+ self.assertEqual(1, len(actions))
+ self.assertEqual("add", actions[0]["action"])
values = actions[0]["values"]
- self.assertEquals(1, len(values))
- self.assertEquals("license-01", values[0]["value"])
+ self.assertEqual(1, len(values))
+ self.assertEqual("license-01", values[0]["value"])
#
# Add an another value to the attribute
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
attributes = messages[0]["dsdbChange"]["attributes"]
- self.assertEquals(1, len(attributes))
+ self.assertEqual(1, len(attributes))
actions = attributes["carLicense"]["actions"]
- self.assertEquals(1, len(actions))
- self.assertEquals("add", actions[0]["action"])
+ self.assertEqual(1, len(actions))
+ self.assertEqual("add", actions[0]["action"])
values = actions[0]["values"]
- self.assertEquals(1, len(values))
- self.assertEquals("license-02", values[0]["value"])
+ self.assertEqual(1, len(values))
+ self.assertEqual("license-02", values[0]["value"])
#
# Add an another two values to the attribute
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
attributes = messages[0]["dsdbChange"]["attributes"]
- self.assertEquals(1, len(attributes))
+ self.assertEqual(1, len(attributes))
actions = attributes["carLicense"]["actions"]
- self.assertEquals(1, len(actions))
- self.assertEquals("add", actions[0]["action"])
+ self.assertEqual(1, len(actions))
+ self.assertEqual("add", actions[0]["action"])
values = actions[0]["values"]
- self.assertEquals(2, len(values))
- self.assertEquals("license-03", values[0]["value"])
- self.assertEquals("license-04", values[1]["value"])
+ self.assertEqual(2, len(values))
+ self.assertEqual("license-03", values[0]["value"])
+ self.assertEqual("license-04", values[1]["value"])
#
# delete two values to the attribute
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
attributes = messages[0]["dsdbChange"]["attributes"]
- self.assertEquals(1, len(attributes))
+ self.assertEqual(1, len(attributes))
actions = attributes["carLicense"]["actions"]
- self.assertEquals(1, len(actions))
- self.assertEquals("delete", actions[0]["action"])
+ self.assertEqual(1, len(actions))
+ self.assertEqual("delete", actions[0]["action"])
values = actions[0]["values"]
- self.assertEquals(2, len(values))
- self.assertEquals("license-03", values[0]["value"])
- self.assertEquals("license-04", values[1]["value"])
+ self.assertEqual(2, len(values))
+ self.assertEqual("license-03", values[0]["value"])
+ self.assertEqual("license-04", values[1]["value"])
#
# replace two values to the attribute
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
attributes = messages[0]["dsdbChange"]["attributes"]
- self.assertEquals(1, len(attributes))
+ self.assertEqual(1, len(attributes))
actions = attributes["carLicense"]["actions"]
- self.assertEquals(1, len(actions))
- self.assertEquals("replace", actions[0]["action"])
+ self.assertEqual(1, len(actions))
+ self.assertEqual("replace", actions[0]["action"])
values = actions[0]["values"]
- self.assertEquals(2, len(values))
- self.assertEquals("license-05", values[0]["value"])
- self.assertEquals("license-06", values[1]["value"])
+ self.assertEqual(2, len(values))
+ self.assertEqual("license-05", values[0]["value"])
+ self.assertEqual("license-06", values[1]["value"])
messages = self.waitForMessages(1, net, dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["passwordChange"]
- self.assertEquals(EVT_ID_PASSWORD_CHANGE, audit["eventId"])
- self.assertEquals("Change", audit["action"])
- self.assertEquals(dn, audit["dn"])
+ self.assertEqual(EVT_ID_PASSWORD_CHANGE, audit["eventId"])
+ self.assertEqual("Change", audit["action"])
+ self.assertEqual(dn, audit["dn"])
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "DCE/RPC")
+ self.assertEqual(service_description, "DCE/RPC")
self.assertTrue(self.is_guid(audit["transactionId"]))
def test_net_set_password_user_without_permission(self):
dn = "CN=" + SECOND_USER_NAME + ",CN=Users," + self.base_dn
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["passwordChange"]
- self.assertEquals(EVT_ID_PASSWORD_RESET, audit["eventId"])
- self.assertEquals("Reset", audit["action"])
- self.assertEquals(dn, audit["dn"])
+ self.assertEqual(EVT_ID_PASSWORD_RESET, audit["eventId"])
+ self.assertEqual("Reset", audit["action"])
+ self.assertEqual(dn, audit["dn"])
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
self.assertTrue(self.is_guid(audit["transactionId"]))
- self.assertEquals(0, audit["statusCode"])
- self.assertEquals("Success", audit["status"])
+ self.assertEqual(0, audit["statusCode"])
+ self.assertEqual("Success", audit["status"])
self.discardMessages()
creds = self.insta_creds(
dn = "CN=" + USER_NAME + ",CN=Users," + self.base_dn
messages = self.waitForMessages(1, net, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["passwordChange"]
- self.assertEquals(EVT_ID_PASSWORD_RESET, audit["eventId"])
- self.assertEquals("Reset", audit["action"])
- self.assertEquals(dn, audit["dn"])
+ self.assertEqual(EVT_ID_PASSWORD_RESET, audit["eventId"])
+ self.assertEqual("Reset", audit["action"])
+ self.assertEqual(dn, audit["dn"])
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "DCE/RPC")
+ self.assertEqual(service_description, "DCE/RPC")
self.assertTrue(self.is_guid(audit["transactionId"]))
- self.assertEquals(ERR_INSUFFICIENT_ACCESS_RIGHTS, audit["statusCode"])
- self.assertEquals("insufficient access rights", audit["status"])
+ self.assertEqual(ERR_INSUFFICIENT_ACCESS_RIGHTS, audit["statusCode"])
+ self.assertEqual("insufficient access rights", audit["status"])
def test_net_set_password(self):
dn = "CN=" + USER_NAME + ",CN=Users," + self.base_dn
messages = self.waitForMessages(1, net, dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["passwordChange"]
- self.assertEquals(EVT_ID_PASSWORD_RESET, audit["eventId"])
- self.assertEquals("Reset", audit["action"])
- self.assertEquals(dn, audit["dn"])
+ self.assertEqual(EVT_ID_PASSWORD_RESET, audit["eventId"])
+ self.assertEqual("Reset", audit["action"])
+ self.assertEqual(dn, audit["dn"])
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "DCE/RPC")
+ self.assertEqual(service_description, "DCE/RPC")
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
self.assertTrue(self.is_guid(audit["transactionId"]))
def test_ldap_change_password(self):
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["passwordChange"]
- self.assertEquals(EVT_ID_PASSWORD_CHANGE, audit["eventId"])
- self.assertEquals("Change", audit["action"])
- self.assertEquals(dn, audit["dn"])
+ self.assertEqual(EVT_ID_PASSWORD_CHANGE, audit["eventId"])
+ self.assertEqual("Change", audit["action"])
+ self.assertEqual(dn, audit["dn"])
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
self.assertTrue(self.is_guid(audit["transactionId"]))
def test_ldap_replace_password(self):
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["passwordChange"]
- self.assertEquals(EVT_ID_PASSWORD_RESET, audit["eventId"])
- self.assertEquals("Reset", audit["action"])
- self.assertEquals(dn, audit["dn"])
+ self.assertEqual(EVT_ID_PASSWORD_RESET, audit["eventId"])
+ self.assertEqual("Reset", audit["action"])
+ self.assertEqual(dn, audit["dn"])
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
self.assertTrue(self.is_guid(audit["transactionId"]))
def test_ldap_add_user(self):
dn = "cn=" + USER_NAME + ",cn=users," + self.base_dn
messages = self.waitForMessages(1, dn=dn)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
# The first message should be the reset from the Setup code.
#
audit = messages[0]["passwordChange"]
- self.assertEquals(EVT_ID_PASSWORD_RESET, audit["eventId"])
- self.assertEquals("Reset", audit["action"])
- self.assertEquals(dn, audit["dn"])
+ self.assertEqual(EVT_ID_PASSWORD_RESET, audit["eventId"])
+ self.assertEqual("Reset", audit["action"])
+ self.assertEqual(dn, audit["dn"])
self.assertRegexpMatches(audit["remoteAddress"],
self.remoteAddress)
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
self.assertTrue(self.is_guid(audit["sessionId"]))
self.assertTrue(self.is_guid(audit["transactionId"]))
# Handle explicit smb2, smb1 or auto negotiation
if "smb2" in binding_list:
- self.assertEquals(serviceDescription, "SMB2")
+ self.assertEqual(serviceDescription, "SMB2")
elif "smb1" in binding_list:
- self.assertEquals(serviceDescription, "SMB")
+ self.assertEqual(serviceDescription, "SMB")
else:
self.assertIn(serviceDescription, ["SMB", "SMB2"])
binding, protection):
expected_messages = len(authTypes)
- self.assertEquals(expected_messages,
+ self.assertEqual(expected_messages,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authentication
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals(
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual(
EVT_ID_SUCCESSFUL_LOGON, msg["Authentication"]["eventId"])
- self.assertEquals(
+ self.assertEqual(
EVT_LOGON_NETWORK, msg["Authentication"]["logonType"])
self._assert_ncacn_np_serviceDescription(
binding, msg["Authentication"]["serviceDescription"])
- self.assertEquals(authTypes[1],
+ self.assertEqual(authTypes[1],
msg["Authentication"]["authDescription"])
# Check the second message it should be an Authorization
msg = messages[1]
- self.assertEquals("Authorization", msg["type"])
+ self.assertEqual("Authorization", msg["type"])
self._assert_ncacn_np_serviceDescription(
binding, msg["Authorization"]["serviceDescription"])
- self.assertEquals(authTypes[2], msg["Authorization"]["authType"])
- self.assertEquals("SMB", msg["Authorization"]["transportProtection"])
+ self.assertEqual(authTypes[2], msg["Authorization"]["authType"])
+ self.assertEqual("SMB", msg["Authorization"]["transportProtection"])
self.assertTrue(self.is_guid(msg["Authorization"]["sessionId"]))
# Check the third message it should be an Authentication
return (desc == "DCE/RPC" or desc == service)
msg = messages[2]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
self.assertTrue(
checkServiceDescription(
msg["Authentication"]["serviceDescription"]))
- self.assertEquals(authTypes[3],
+ self.assertEqual(authTypes[3],
msg["Authentication"]["authDescription"])
- self.assertEquals(
+ self.assertEqual(
EVT_ID_SUCCESSFUL_LOGON, msg["Authentication"]["eventId"])
- self.assertEquals(
+ self.assertEqual(
EVT_LOGON_NETWORK, msg["Authentication"]["logonType"])
def rpc_ncacn_np_krb5_check(
protection):
expected_messages = len(authTypes)
- self.assertEquals(expected_messages,
+ self.assertEqual(expected_messages,
len(messages),
"Did not receive the expected number of messages")
# This is almost certainly Authentication over UDP, and is probably
# returning message too big,
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("Kerberos KDC",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("Kerberos KDC",
msg["Authentication"]["serviceDescription"])
- self.assertEquals(authTypes[1],
+ self.assertEqual(authTypes[1],
msg["Authentication"]["authDescription"])
- self.assertEquals(
+ self.assertEqual(
EVT_ID_SUCCESSFUL_LOGON, msg["Authentication"]["eventId"])
- self.assertEquals(
+ self.assertEqual(
EVT_LOGON_NETWORK, msg["Authentication"]["logonType"])
# Check the second message it should be an Authentication
# This this the TCP Authentication in response to the message too big
# response to the UDP Authentication
msg = messages[1]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("Kerberos KDC",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("Kerberos KDC",
msg["Authentication"]["serviceDescription"])
- self.assertEquals(authTypes[2],
+ self.assertEqual(authTypes[2],
msg["Authentication"]["authDescription"])
- self.assertEquals(
+ self.assertEqual(
EVT_ID_SUCCESSFUL_LOGON, msg["Authentication"]["eventId"])
- self.assertEquals(
+ self.assertEqual(
EVT_LOGON_NETWORK, msg["Authentication"]["logonType"])
# Check the third message it should be an Authorization
msg = messages[2]
- self.assertEquals("Authorization", msg["type"])
+ self.assertEqual("Authorization", msg["type"])
self._assert_ncacn_np_serviceDescription(
binding, msg["Authorization"]["serviceDescription"])
- self.assertEquals(authTypes[3], msg["Authorization"]["authType"])
- self.assertEquals("SMB", msg["Authorization"]["transportProtection"])
+ self.assertEqual(authTypes[3], msg["Authorization"]["authType"])
+ self.assertEqual("SMB", msg["Authorization"]["transportProtection"])
self.assertTrue(self.is_guid(msg["Authorization"]["sessionId"]))
def test_rpc_ncacn_np_ntlm_dns_sign(self):
binding, protection):
expected_messages = len(authTypes)
- self.assertEquals(expected_messages,
+ self.assertEqual(expected_messages,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authorization
msg = messages[0]
- self.assertEquals("Authorization", msg["type"])
- self.assertEquals("DCE/RPC",
+ self.assertEqual("Authorization", msg["type"])
+ self.assertEqual("DCE/RPC",
msg["Authorization"]["serviceDescription"])
- self.assertEquals(authTypes[1], msg["Authorization"]["authType"])
- self.assertEquals("NONE", msg["Authorization"]["transportProtection"])
+ self.assertEqual(authTypes[1], msg["Authorization"]["authType"])
+ self.assertEqual("NONE", msg["Authorization"]["transportProtection"])
self.assertTrue(self.is_guid(msg["Authorization"]["sessionId"]))
# Check the second message it should be an Authentication
msg = messages[1]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("DCE/RPC",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("DCE/RPC",
msg["Authentication"]["serviceDescription"])
- self.assertEquals(authTypes[2],
+ self.assertEqual(authTypes[2],
msg["Authentication"]["authDescription"])
- self.assertEquals(
+ self.assertEqual(
EVT_ID_SUCCESSFUL_LOGON, msg["Authentication"]["eventId"])
- self.assertEquals(
+ self.assertEqual(
EVT_LOGON_NETWORK, msg["Authentication"]["logonType"])
def rpc_ncacn_ip_tcp_krb5_check(self, messages, authTypes, service,
binding, protection):
expected_messages = len(authTypes)
- self.assertEquals(expected_messages,
+ self.assertEqual(expected_messages,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authorization
msg = messages[0]
- self.assertEquals("Authorization", msg["type"])
- self.assertEquals("DCE/RPC",
+ self.assertEqual("Authorization", msg["type"])
+ self.assertEqual("DCE/RPC",
msg["Authorization"]["serviceDescription"])
- self.assertEquals(authTypes[1], msg["Authorization"]["authType"])
- self.assertEquals("NONE", msg["Authorization"]["transportProtection"])
+ self.assertEqual(authTypes[1], msg["Authorization"]["authType"])
+ self.assertEqual("NONE", msg["Authorization"]["transportProtection"])
self.assertTrue(self.is_guid(msg["Authorization"]["sessionId"]))
# Check the second message it should be an Authentication
msg = messages[1]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("Kerberos KDC",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("Kerberos KDC",
msg["Authentication"]["serviceDescription"])
- self.assertEquals(authTypes[2],
+ self.assertEqual(authTypes[2],
msg["Authentication"]["authDescription"])
- self.assertEquals(
+ self.assertEqual(
EVT_ID_SUCCESSFUL_LOGON, msg["Authentication"]["eventId"])
- self.assertEquals(
+ self.assertEqual(
EVT_LOGON_NETWORK, msg["Authentication"]["logonType"])
# Check the third message it should be an Authentication
msg = messages[2]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("Kerberos KDC",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("Kerberos KDC",
msg["Authentication"]["serviceDescription"])
- self.assertEquals(authTypes[2],
+ self.assertEqual(authTypes[2],
msg["Authentication"]["authDescription"])
- self.assertEquals(
+ self.assertEqual(
EVT_ID_SUCCESSFUL_LOGON, msg["Authentication"]["eventId"])
- self.assertEquals(
+ self.assertEqual(
EVT_LOGON_NETWORK, msg["Authentication"]["logonType"])
def test_rpc_ncacn_ip_tcp_ntlm_dns_sign(self):
credentials=self.get_credentials())
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(3,
+ self.assertEqual(3,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authentication
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("Kerberos KDC",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("Kerberos KDC",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("ENC-TS Pre-authentication",
+ self.assertEqual("ENC-TS Pre-authentication",
msg["Authentication"]["authDescription"])
self.assertTrue(msg["Authentication"]["duration"] > 0)
- self.assertEquals(
+ self.assertEqual(
EVT_ID_SUCCESSFUL_LOGON, msg["Authentication"]["eventId"])
- self.assertEquals(
+ self.assertEqual(
EVT_LOGON_NETWORK, msg["Authentication"]["logonType"])
# Check the second message it should be an Authentication
msg = messages[1]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("Kerberos KDC",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("Kerberos KDC",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("ENC-TS Pre-authentication",
+ self.assertEqual("ENC-TS Pre-authentication",
msg["Authentication"]["authDescription"])
self.assertTrue(msg["Authentication"]["duration"] > 0)
- self.assertEquals(
+ self.assertEqual(
EVT_ID_SUCCESSFUL_LOGON, msg["Authentication"]["eventId"])
- self.assertEquals(
+ self.assertEqual(
EVT_LOGON_NETWORK, msg["Authentication"]["logonType"])
def test_ldap_ntlm(self):
credentials=self.get_credentials())
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(2,
+ self.assertEqual(2,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authentication
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("LDAP",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("LDAP",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("NTLMSSP", msg["Authentication"]["authDescription"])
+ self.assertEqual("NTLMSSP", msg["Authentication"]["authDescription"])
self.assertTrue(msg["Authentication"]["duration"] > 0)
- self.assertEquals(
+ self.assertEqual(
EVT_ID_SUCCESSFUL_LOGON, msg["Authentication"]["eventId"])
- self.assertEquals(
+ self.assertEqual(
EVT_LOGON_NETWORK, msg["Authentication"]["logonType"])
def test_ldap_simple_bind(self):
credentials=creds)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(2,
+ self.assertEqual(2,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authentication
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("LDAP",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("LDAP",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("simple bind",
+ self.assertEqual("simple bind",
msg["Authentication"]["authDescription"])
- self.assertEquals(
+ self.assertEqual(
EVT_ID_SUCCESSFUL_LOGON, msg["Authentication"]["eventId"])
- self.assertEquals(
+ self.assertEqual(
EVT_LOGON_NETWORK_CLEAR_TEXT, msg["Authentication"]["logonType"])
def test_ldap_simple_bind_bad_password(self):
credentials=creds)
except LdbError:
thrown = True
- self.assertEquals(thrown, True)
+ self.assertEqual(thrown, True)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
credentials=creds)
except LdbError:
thrown = True
- self.assertEquals(thrown, True)
+ self.assertEqual(thrown, True)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
credentials=creds)
except LdbError:
thrown = True
- self.assertEquals(thrown, True)
+ self.assertEqual(thrown, True)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
credentials=creds)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(0,
+ self.assertEqual(0,
len(messages),
"Did not receive the expected number of messages")
pass
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
self.smb_connection(creds)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(3,
+ self.assertEqual(3,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authentication
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("Kerberos KDC",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("Kerberos KDC",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("ENC-TS Pre-authentication",
+ self.assertEqual("ENC-TS Pre-authentication",
msg["Authentication"]["authDescription"])
- self.assertEquals(EVT_ID_SUCCESSFUL_LOGON,
+ self.assertEqual(EVT_ID_SUCCESSFUL_LOGON,
msg["Authentication"]["eventId"])
- self.assertEquals(EVT_LOGON_NETWORK,
+ self.assertEqual(EVT_LOGON_NETWORK,
msg["Authentication"]["logonType"])
# Check the second message it should be an Authentication
msg = messages[1]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("Kerberos KDC",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("Kerberos KDC",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("ENC-TS Pre-authentication",
+ self.assertEqual("ENC-TS Pre-authentication",
msg["Authentication"]["authDescription"])
- self.assertEquals(EVT_ID_SUCCESSFUL_LOGON,
+ self.assertEqual(EVT_ID_SUCCESSFUL_LOGON,
msg["Authentication"]["eventId"])
- self.assertEquals(EVT_LOGON_NETWORK,
+ self.assertEqual(EVT_LOGON_NETWORK,
msg["Authentication"]["logonType"])
def test_smb_bad_password(self):
self.smb_connection(creds)
except NTSTATUSError:
thrown = True
- self.assertEquals(thrown, True)
+ self.assertEqual(thrown, True)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
self.smb_connection(creds)
except NTSTATUSError:
thrown = True
- self.assertEquals(thrown, True)
+ self.assertEqual(thrown, True)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
call(["bin/smbclient", path, auth, "-mNT1", "-c quit"])
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(3,
+ self.assertEqual(3,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authentication
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_NO_SUCH_USER",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_NO_SUCH_USER",
msg["Authentication"]["status"])
- self.assertEquals("SMB",
+ self.assertEqual("SMB",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("NTLMSSP",
+ self.assertEqual("NTLMSSP",
msg["Authentication"]["authDescription"])
- self.assertEquals("No-Password",
+ self.assertEqual("No-Password",
msg["Authentication"]["passwordType"])
- self.assertEquals(EVT_ID_UNSUCCESSFUL_LOGON,
+ self.assertEqual(EVT_ID_UNSUCCESSFUL_LOGON,
msg["Authentication"]["eventId"])
- self.assertEquals(EVT_LOGON_NETWORK,
+ self.assertEqual(EVT_LOGON_NETWORK,
msg["Authentication"]["logonType"])
# Check the second message it should be an Authentication
msg = messages[1]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK",
msg["Authentication"]["status"])
- self.assertEquals("SMB",
+ self.assertEqual("SMB",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("NTLMSSP",
+ self.assertEqual("NTLMSSP",
msg["Authentication"]["authDescription"])
- self.assertEquals("No-Password",
+ self.assertEqual("No-Password",
msg["Authentication"]["passwordType"])
- self.assertEquals("ANONYMOUS LOGON",
+ self.assertEqual("ANONYMOUS LOGON",
msg["Authentication"]["becameAccount"])
- self.assertEquals(EVT_ID_SUCCESSFUL_LOGON,
+ self.assertEqual(EVT_ID_SUCCESSFUL_LOGON,
msg["Authentication"]["eventId"])
- self.assertEquals(EVT_LOGON_NETWORK,
+ self.assertEqual(EVT_LOGON_NETWORK,
msg["Authentication"]["logonType"])
def test_smb2_anonymous(self):
call(["bin/smbclient", path, auth, "-mSMB3", "-c quit"])
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(3,
+ self.assertEqual(3,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authentication
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_NO_SUCH_USER",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_NO_SUCH_USER",
msg["Authentication"]["status"])
- self.assertEquals("SMB2",
+ self.assertEqual("SMB2",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("NTLMSSP",
+ self.assertEqual("NTLMSSP",
msg["Authentication"]["authDescription"])
- self.assertEquals("No-Password",
+ self.assertEqual("No-Password",
msg["Authentication"]["passwordType"])
- self.assertEquals(EVT_ID_UNSUCCESSFUL_LOGON,
+ self.assertEqual(EVT_ID_UNSUCCESSFUL_LOGON,
msg["Authentication"]["eventId"])
- self.assertEquals(EVT_LOGON_NETWORK,
+ self.assertEqual(EVT_LOGON_NETWORK,
msg["Authentication"]["logonType"])
# Check the second message it should be an Authentication
msg = messages[1]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK",
msg["Authentication"]["status"])
- self.assertEquals("SMB2",
+ self.assertEqual("SMB2",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("NTLMSSP",
+ self.assertEqual("NTLMSSP",
msg["Authentication"]["authDescription"])
- self.assertEquals("No-Password",
+ self.assertEqual("No-Password",
msg["Authentication"]["passwordType"])
- self.assertEquals("ANONYMOUS LOGON",
+ self.assertEqual("ANONYMOUS LOGON",
msg["Authentication"]["becameAccount"])
- self.assertEquals(EVT_ID_SUCCESSFUL_LOGON,
+ self.assertEqual(EVT_ID_SUCCESSFUL_LOGON,
msg["Authentication"]["eventId"])
- self.assertEquals(EVT_LOGON_NETWORK,
+ self.assertEqual(EVT_LOGON_NETWORK,
msg["Authentication"]["logonType"])
def test_smb_no_krb_spnego(self):
self.smb_connection(creds)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(2,
+ self.assertEqual(2,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authentication
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
self.assertIn(msg["Authentication"]["serviceDescription"],
["SMB", "SMB2"])
- self.assertEquals("NTLMSSP",
+ self.assertEqual("NTLMSSP",
msg["Authentication"]["authDescription"])
- self.assertEquals("NTLMv2",
+ self.assertEqual("NTLMv2",
msg["Authentication"]["passwordType"])
- self.assertEquals(EVT_ID_SUCCESSFUL_LOGON,
+ self.assertEqual(EVT_ID_SUCCESSFUL_LOGON,
msg["Authentication"]["eventId"])
- self.assertEquals(EVT_LOGON_NETWORK,
+ self.assertEqual(EVT_LOGON_NETWORK,
msg["Authentication"]["logonType"])
def test_smb_no_krb_spnego_bad_password(self):
self.smb_connection(creds)
except NTSTATUSError:
thrown = True
- self.assertEquals(thrown, True)
+ self.assertEqual(thrown, True)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
self.smb_connection(creds)
except NTSTATUSError:
thrown = True
- self.assertEquals(thrown, True)
+ self.assertEqual(thrown, True)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
use_spnego="no")
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(2,
+ self.assertEqual(2,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authentication
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("SMB",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("SMB",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("bare-NTLM",
+ self.assertEqual("bare-NTLM",
msg["Authentication"]["authDescription"])
- self.assertEquals("NTLMv1",
+ self.assertEqual("NTLMv1",
msg["Authentication"]["passwordType"])
- self.assertEquals(EVT_ID_SUCCESSFUL_LOGON,
+ self.assertEqual(EVT_ID_SUCCESSFUL_LOGON,
msg["Authentication"]["eventId"])
- self.assertEquals(EVT_LOGON_NETWORK,
+ self.assertEqual(EVT_LOGON_NETWORK,
msg["Authentication"]["logonType"])
def test_smb_no_krb_no_spnego_no_ntlmv2_bad_password(self):
use_spnego="no")
except NTSTATUSError:
thrown = True
- self.assertEquals(thrown, True)
+ self.assertEqual(thrown, True)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
use_spnego="no")
except NTSTATUSError:
thrown = True
- self.assertEquals(thrown, True)
+ self.assertEqual(thrown, True)
messages = self.waitForMessages(isLastExpectedMessage)
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
# Check the second to last message it should be an Authorization
msg = messages[-2]
- self.assertEquals("Authorization", msg["type"])
- self.assertEquals("DCE/RPC",
+ self.assertEqual("Authorization", msg["type"])
+ self.assertEqual("DCE/RPC",
msg["Authorization"]["serviceDescription"])
- self.assertEquals("schannel", msg["Authorization"]["authType"])
- self.assertEquals("SEAL", msg["Authorization"]["transportProtection"])
+ self.assertEqual("schannel", msg["Authorization"]["authType"])
+ self.assertEqual("SEAL", msg["Authorization"]["transportProtection"])
self.assertTrue(self.is_guid(msg["Authorization"]["sessionId"]))
# Signed logons get promoted to sealed, this test ensures that
# Check the second to last message it should be an Authorization
msg = messages[-2]
- self.assertEquals("Authorization", msg["type"])
- self.assertEquals("DCE/RPC",
+ self.assertEqual("Authorization", msg["type"])
+ self.assertEqual("DCE/RPC",
msg["Authorization"]["serviceDescription"])
- self.assertEquals("schannel", msg["Authorization"]["authType"])
- self.assertEquals("SEAL", msg["Authorization"]["transportProtection"])
+ self.assertEqual("schannel", msg["Authorization"]["authType"])
+ self.assertEqual("SEAL", msg["Authorization"]["transportProtection"])
self.assertTrue(self.is_guid(msg["Authorization"]["sessionId"]))
def rpc_ncacn_np_ntlm_check(self, messages, authTypes, protection):
expected_messages = len(authTypes)
- self.assertEquals(expected_messages,
+ self.assertEqual(expected_messages,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authorization
msg = messages[0]
- self.assertEquals("Authorization", msg["type"])
- self.assertEquals("DCE/RPC",
+ self.assertEqual("Authorization", msg["type"])
+ self.assertEqual("DCE/RPC",
msg["Authorization"]["serviceDescription"])
- self.assertEquals(authTypes[1], msg["Authorization"]["authType"])
- self.assertEquals("NONE", msg["Authorization"]["transportProtection"])
+ self.assertEqual(authTypes[1], msg["Authorization"]["authType"])
+ self.assertEqual("NONE", msg["Authorization"]["transportProtection"])
self.assertTrue(self.is_guid(msg["Authorization"]["sessionId"]))
# Check the second message it should be an Authentication
msg = messages[1]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals("DCE/RPC",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual("DCE/RPC",
msg["Authentication"]["serviceDescription"])
- self.assertEquals(authTypes[2],
+ self.assertEqual(authTypes[2],
msg["Authentication"]["authDescription"])
- self.assertEquals(EVT_ID_SUCCESSFUL_LOGON,
+ self.assertEqual(EVT_ID_SUCCESSFUL_LOGON,
msg["Authentication"]["eventId"])
- self.assertEquals(EVT_LOGON_NETWORK,
+ self.assertEqual(EVT_LOGON_NETWORK,
msg["Authentication"]["logonType"])
def test_ncalrpc_ntlm_dns_sign(self):
def netlogon_check(self, messages):
expected_messages = 5
- self.assertEquals(expected_messages,
+ self.assertEqual(expected_messages,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authorization
msg = messages[0]
- self.assertEquals("Authorization", msg["type"])
- self.assertEquals("DCE/RPC",
+ self.assertEqual("Authorization", msg["type"])
+ self.assertEqual("DCE/RPC",
msg["Authorization"]["serviceDescription"])
- self.assertEquals("ncalrpc", msg["Authorization"]["authType"])
- self.assertEquals("NONE", msg["Authorization"]["transportProtection"])
+ self.assertEqual("ncalrpc", msg["Authorization"]["authType"])
+ self.assertEqual("NONE", msg["Authorization"]["transportProtection"])
self.assertTrue(self.is_guid(msg["Authorization"]["sessionId"]))
# Check the fourth message it should be a NETLOGON Authentication
msg = messages[3]
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals("NETLOGON",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual("NETLOGON",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("ServerAuthenticate",
+ self.assertEqual("ServerAuthenticate",
msg["Authentication"]["authDescription"])
- self.assertEquals("NT_STATUS_OK",
+ self.assertEqual("NT_STATUS_OK",
msg["Authentication"]["status"])
- self.assertEquals("HMAC-SHA256",
+ self.assertEqual("HMAC-SHA256",
msg["Authentication"]["passwordType"])
- self.assertEquals(EVT_ID_SUCCESSFUL_LOGON,
+ self.assertEqual(EVT_ID_SUCCESSFUL_LOGON,
msg["Authentication"]["eventId"])
- self.assertEquals(EVT_LOGON_NETWORK,
+ self.assertEqual(EVT_LOGON_NETWORK,
msg["Authentication"]["logonType"])
def test_netlogon(self):
def netlogon_check(self, messages):
expected_messages = 4
- self.assertEquals(expected_messages,
+ self.assertEqual(expected_messages,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authorization
msg = messages[0]
- self.assertEquals("Authorization", msg["type"])
- self.assertEquals("DCE/RPC",
+ self.assertEqual("Authorization", msg["type"])
+ self.assertEqual("DCE/RPC",
msg["Authorization"]["serviceDescription"])
- self.assertEquals("ncalrpc", msg["Authorization"]["authType"])
- self.assertEquals("NONE", msg["Authorization"]["transportProtection"])
+ self.assertEqual("ncalrpc", msg["Authorization"]["authType"])
+ self.assertEqual("NONE", msg["Authorization"]["transportProtection"])
self.assertTrue(self.is_guid(msg["Authorization"]["sessionId"]))
def test_netlogon_bad_machine_name(self):
username=USER_NAME)
except Exception:
exception_thrown = True
- self.assertEquals(True, exception_thrown,
+ self.assertEqual(True, exception_thrown,
"Expected exception not thrown")
self.assertTrue(self.waitForMessages(isLastExpectedMessage),
"Did not receive the expected message")
username="badUser")
except Exception:
exception_thrown = True
- self.assertEquals(True, exception_thrown,
+ self.assertEqual(True, exception_thrown,
"Expected exception not thrown")
self.assertTrue(self.waitForMessages(isLastExpectedMessage),
username=USER_NAME)
except Exception:
exception_thrown = True
- self.assertEquals(True, exception_thrown,
+ self.assertEqual(True, exception_thrown,
"Expected exception not thrown")
self.assertTrue(self.waitForMessages(isLastExpectedMessage),
messages = self.remove_netlogon_messages(messages)
expected_messages = 5
- self.assertEquals(expected_messages,
+ self.assertEqual(expected_messages,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authorization
msg = messages[0]
- self.assertEquals("Authorization", msg["type"])
- self.assertEquals("DCE/RPC",
+ self.assertEqual("Authorization", msg["type"])
+ self.assertEqual("DCE/RPC",
msg["Authorization"]["serviceDescription"])
- self.assertEquals("ncalrpc", msg["Authorization"]["authType"])
- self.assertEquals("NONE", msg["Authorization"]["transportProtection"])
+ self.assertEqual("ncalrpc", msg["Authorization"]["authType"])
+ self.assertEqual("NONE", msg["Authorization"]["transportProtection"])
self.assertTrue(self.is_guid(msg["Authorization"]["sessionId"]))
def test_ncalrpc_samlogon(self):
#
# Validate that message contains the expected data
#
- self.assertEquals("Authentication", msg["type"])
- self.assertEquals(logon_id, msg["Authentication"]["logonId"])
- self.assertEquals("SamLogon",
+ self.assertEqual("Authentication", msg["type"])
+ self.assertEqual(logon_id, msg["Authentication"]["logonId"])
+ self.assertEqual("SamLogon",
msg["Authentication"]["serviceDescription"])
- self.assertEquals(description,
+ self.assertEqual(description,
msg["Authentication"]["authDescription"])
def test_ntlm_auth(self):
messages = self.waitForMessages(isLastExpectedMessage)
messages = self.filter_messages(messages)
expected_messages = 1
- self.assertEquals(expected_messages,
+ self.assertEqual(expected_messages,
len(messages),
"Did not receive the expected number of messages")
# Check the first message it should be an Authentication
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
+ self.assertEqual("Authentication", msg["type"])
self.assertTrue(
msg["Authentication"]["authDescription"].startswith(
"PAM_AUTH, ntlm_auth,"))
- self.assertEquals("winbind",
+ self.assertEqual("winbind",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("Plaintext", msg["Authentication"]["passwordType"])
+ self.assertEqual("Plaintext", msg["Authentication"]["passwordType"])
# Logon type should be NetworkCleartext
- self.assertEquals(8, msg["Authentication"]["logonType"])
+ self.assertEqual(8, msg["Authentication"]["logonType"])
# Event code should be Successful logon
- self.assertEquals(4624, msg["Authentication"]["eventId"])
- self.assertEquals("unix:", msg["Authentication"]["remoteAddress"])
- self.assertEquals("unix:", msg["Authentication"]["localAddress"])
- self.assertEquals(self.domain, msg["Authentication"]["clientDomain"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
- self.assertEquals(self.credentials.get_username(),
+ self.assertEqual(4624, msg["Authentication"]["eventId"])
+ self.assertEqual("unix:", msg["Authentication"]["remoteAddress"])
+ self.assertEqual("unix:", msg["Authentication"]["localAddress"])
+ self.assertEqual(self.domain, msg["Authentication"]["clientDomain"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual(self.credentials.get_username(),
msg["Authentication"]["clientAccount"])
- self.assertEquals(self.credentials.get_domain(),
+ self.assertEqual(self.credentials.get_domain(),
msg["Authentication"]["clientDomain"])
self.assertTrue(msg["Authentication"]["workstation"] is None)
messages = self.waitForMessages(isLastExpectedMessage)
messages = self.filter_messages(messages)
expected_messages = 3
- self.assertEquals(expected_messages,
+ self.assertEqual(expected_messages,
len(messages),
"Did not receive the expected number of messages")
# The 1st message should be an Authentication against the local
# password database
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
+ self.assertEqual("Authentication", msg["type"])
self.assertTrue(msg["Authentication"]["authDescription"].startswith(
"PASSDB, wbinfo,"))
- self.assertEquals("winbind",
+ self.assertEqual("winbind",
msg["Authentication"]["serviceDescription"])
# Logon type should be Interactive
- self.assertEquals(2, msg["Authentication"]["logonType"])
+ self.assertEqual(2, msg["Authentication"]["logonType"])
# Event code should be Unsuccessful logon
- self.assertEquals(4625, msg["Authentication"]["eventId"])
- self.assertEquals("unix:", msg["Authentication"]["remoteAddress"])
- self.assertEquals("unix:", msg["Authentication"]["localAddress"])
- self.assertEquals('', msg["Authentication"]["clientDomain"])
+ self.assertEqual(4625, msg["Authentication"]["eventId"])
+ self.assertEqual("unix:", msg["Authentication"]["remoteAddress"])
+ self.assertEqual("unix:", msg["Authentication"]["localAddress"])
+ self.assertEqual('', msg["Authentication"]["clientDomain"])
# This is what the existing winbind implementation returns.
- self.assertEquals("NT_STATUS_NO_SUCH_USER",
+ self.assertEqual("NT_STATUS_NO_SUCH_USER",
msg["Authentication"]["status"])
- self.assertEquals("NTLMv2", msg["Authentication"]["passwordType"])
- self.assertEquals(self.credentials.get_username(),
+ self.assertEqual("NTLMv2", msg["Authentication"]["passwordType"])
+ self.assertEqual(self.credentials.get_username(),
msg["Authentication"]["clientAccount"])
- self.assertEquals("", msg["Authentication"]["clientDomain"])
+ self.assertEqual("", msg["Authentication"]["clientDomain"])
logon_id = msg["Authentication"]["logonId"]
# The 2nd message should be a PAM_AUTH with the same logon id as the
# 1st message
msg = messages[1]
- self.assertEquals("Authentication", msg["type"])
+ self.assertEqual("Authentication", msg["type"])
self.assertTrue(msg["Authentication"]["authDescription"].startswith(
"PAM_AUTH"))
- self.assertEquals("winbind",
+ self.assertEqual("winbind",
msg["Authentication"]["serviceDescription"])
- self.assertEquals(logon_id, msg["Authentication"]["logonId"])
+ self.assertEqual(logon_id, msg["Authentication"]["logonId"])
# Logon type should be NetworkCleartext
- self.assertEquals(8, msg["Authentication"]["logonType"])
+ self.assertEqual(8, msg["Authentication"]["logonType"])
# Event code should be Unsuccessful logon
- self.assertEquals(4625, msg["Authentication"]["eventId"])
- self.assertEquals("unix:", msg["Authentication"]["remoteAddress"])
- self.assertEquals("unix:", msg["Authentication"]["localAddress"])
- self.assertEquals('', msg["Authentication"]["clientDomain"])
+ self.assertEqual(4625, msg["Authentication"]["eventId"])
+ self.assertEqual("unix:", msg["Authentication"]["remoteAddress"])
+ self.assertEqual("unix:", msg["Authentication"]["localAddress"])
+ self.assertEqual('', msg["Authentication"]["clientDomain"])
# This is what the existing winbind implementation returns.
- self.assertEquals("NT_STATUS_NO_SUCH_USER",
+ self.assertEqual("NT_STATUS_NO_SUCH_USER",
msg["Authentication"]["status"])
- self.assertEquals(self.credentials.get_username(),
+ self.assertEqual(self.credentials.get_username(),
msg["Authentication"]["clientAccount"])
- self.assertEquals("", msg["Authentication"]["clientDomain"])
+ self.assertEqual("", msg["Authentication"]["clientDomain"])
# The 3rd message should be an NTLM_AUTH
msg = messages[2]
- self.assertEquals("Authentication", msg["type"])
+ self.assertEqual("Authentication", msg["type"])
self.assertTrue(msg["Authentication"]["authDescription"].startswith(
"NTLM_AUTH, wbinfo,"))
- self.assertEquals("winbind",
+ self.assertEqual("winbind",
msg["Authentication"]["serviceDescription"])
# Logon type should be Network
- self.assertEquals(3, msg["Authentication"]["logonType"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual(3, msg["Authentication"]["logonType"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
# Event code should be successful logon
- self.assertEquals(4624, msg["Authentication"]["eventId"])
- self.assertEquals("NTLMv2", msg["Authentication"]["passwordType"])
- self.assertEquals("unix:", msg["Authentication"]["remoteAddress"])
- self.assertEquals("unix:", msg["Authentication"]["localAddress"])
- self.assertEquals(self.credentials.get_username(),
+ self.assertEqual(4624, msg["Authentication"]["eventId"])
+ self.assertEqual("NTLMv2", msg["Authentication"]["passwordType"])
+ self.assertEqual("unix:", msg["Authentication"]["remoteAddress"])
+ self.assertEqual("unix:", msg["Authentication"]["localAddress"])
+ self.assertEqual(self.credentials.get_username(),
msg["Authentication"]["clientAccount"])
- self.assertEquals(self.credentials.get_domain(),
+ self.assertEqual(self.credentials.get_domain(),
msg["Authentication"]["clientDomain"])
logon_id = msg["Authentication"]["logonId"]
messages = self.waitForMessages(isLastExpectedMessage)
messages = self.filter_messages(messages)
expected_messages = 3
- self.assertEquals(expected_messages,
+ self.assertEqual(expected_messages,
len(messages),
"Did not receive the expected number of messages")
# The 1st message should be an Authentication against the local
# password database
msg = messages[0]
- self.assertEquals("Authentication", msg["type"])
+ self.assertEqual("Authentication", msg["type"])
self.assertTrue(msg["Authentication"]["authDescription"].startswith(
"PASSDB, wbinfo,"))
- self.assertEquals("winbind",
+ self.assertEqual("winbind",
msg["Authentication"]["serviceDescription"])
# Logon type should be Interactive
- self.assertEquals(2, msg["Authentication"]["logonType"])
+ self.assertEqual(2, msg["Authentication"]["logonType"])
# Event code should be Unsuccessful logon
- self.assertEquals(4625, msg["Authentication"]["eventId"])
- self.assertEquals("unix:", msg["Authentication"]["remoteAddress"])
- self.assertEquals("unix:", msg["Authentication"]["localAddress"])
- self.assertEquals('', msg["Authentication"]["clientDomain"])
+ self.assertEqual(4625, msg["Authentication"]["eventId"])
+ self.assertEqual("unix:", msg["Authentication"]["remoteAddress"])
+ self.assertEqual("unix:", msg["Authentication"]["localAddress"])
+ self.assertEqual('', msg["Authentication"]["clientDomain"])
# This is what the existing winbind implementation returns.
- self.assertEquals("NT_STATUS_NO_SUCH_USER",
+ self.assertEqual("NT_STATUS_NO_SUCH_USER",
msg["Authentication"]["status"])
- self.assertEquals("NTLMv2", msg["Authentication"]["passwordType"])
- self.assertEquals(self.credentials.get_username(),
+ self.assertEqual("NTLMv2", msg["Authentication"]["passwordType"])
+ self.assertEqual(self.credentials.get_username(),
msg["Authentication"]["clientAccount"])
- self.assertEquals("", msg["Authentication"]["clientDomain"])
+ self.assertEqual("", msg["Authentication"]["clientDomain"])
logon_id = msg["Authentication"]["logonId"]
# The 2nd message should be a PAM_AUTH with the same logon id as the
# 1st message
msg = messages[1]
- self.assertEquals("Authentication", msg["type"])
+ self.assertEqual("Authentication", msg["type"])
self.assertTrue(msg["Authentication"]["authDescription"].startswith(
"PAM_AUTH"))
- self.assertEquals("winbind",
+ self.assertEqual("winbind",
msg["Authentication"]["serviceDescription"])
- self.assertEquals(logon_id, msg["Authentication"]["logonId"])
- self.assertEquals("Plaintext", msg["Authentication"]["passwordType"])
+ self.assertEqual(logon_id, msg["Authentication"]["logonId"])
+ self.assertEqual("Plaintext", msg["Authentication"]["passwordType"])
# Logon type should be NetworkCleartext
- self.assertEquals(8, msg["Authentication"]["logonType"])
+ self.assertEqual(8, msg["Authentication"]["logonType"])
# Event code should be Unsuccessful logon
- self.assertEquals(4625, msg["Authentication"]["eventId"])
- self.assertEquals("unix:", msg["Authentication"]["remoteAddress"])
- self.assertEquals("unix:", msg["Authentication"]["localAddress"])
- self.assertEquals('', msg["Authentication"]["clientDomain"])
+ self.assertEqual(4625, msg["Authentication"]["eventId"])
+ self.assertEqual("unix:", msg["Authentication"]["remoteAddress"])
+ self.assertEqual("unix:", msg["Authentication"]["localAddress"])
+ self.assertEqual('', msg["Authentication"]["clientDomain"])
# This is what the existing winbind implementation returns.
- self.assertEquals("NT_STATUS_NO_SUCH_USER",
+ self.assertEqual("NT_STATUS_NO_SUCH_USER",
msg["Authentication"]["status"])
- self.assertEquals(self.credentials.get_username(),
+ self.assertEqual(self.credentials.get_username(),
msg["Authentication"]["clientAccount"])
- self.assertEquals("", msg["Authentication"]["clientDomain"])
+ self.assertEqual("", msg["Authentication"]["clientDomain"])
# The 3rd message should be an NTLM_AUTH
msg = messages[2]
- self.assertEquals("Authentication", msg["type"])
+ self.assertEqual("Authentication", msg["type"])
self.assertTrue(msg["Authentication"]["authDescription"].startswith(
"NTLM_AUTH, wbinfo,"))
- self.assertEquals("winbind",
+ self.assertEqual("winbind",
msg["Authentication"]["serviceDescription"])
- self.assertEquals("NTLMv1",
+ self.assertEqual("NTLMv1",
msg["Authentication"]["passwordType"])
# Logon type should be Network
- self.assertEquals(3, msg["Authentication"]["logonType"])
- self.assertEquals("NT_STATUS_OK", msg["Authentication"]["status"])
+ self.assertEqual(3, msg["Authentication"]["logonType"])
+ self.assertEqual("NT_STATUS_OK", msg["Authentication"]["status"])
# Event code should be successful logon
- self.assertEquals(4624, msg["Authentication"]["eventId"])
- self.assertEquals("unix:", msg["Authentication"]["remoteAddress"])
- self.assertEquals("unix:", msg["Authentication"]["localAddress"])
- self.assertEquals(self.credentials.get_username(),
+ self.assertEqual(4624, msg["Authentication"]["eventId"])
+ self.assertEqual("unix:", msg["Authentication"]["remoteAddress"])
+ self.assertEqual("unix:", msg["Authentication"]["localAddress"])
+ self.assertEqual(self.credentials.get_username(),
msg["Authentication"]["clientAccount"])
- self.assertEquals(self.credentials.get_domain(),
+ self.assertEqual(self.credentials.get_domain(),
msg["Authentication"]["clientDomain"])
logon_id = msg["Authentication"]["logonId"]
actual = output.decode('utf-8').splitlines()
expected = ["%s/%s" % (self.sharepath, file) for file in testfiles]
- self.assertEquals(expected, actual)
+ self.assertEqual(expected, actual)
actual_ngrams = {k: sorted(v) for k, v in actual.ngrams.items()}
expected_ngrams = {k: sorted(v) for k, v in expected.ngrams.items()}
- self.assertEquals(expected_ngrams, actual_ngrams)
+ self.assertEqual(expected_ngrams, actual_ngrams)
actual_details = {k: sorted(v) for k, v in actual.query_details.items()}
expected_details = {k: sorted(v) for k, v in expected.query_details.items()}
- self.assertEquals(expected_details, actual_details)
- self.assertEquals(expected.cumulative_duration, actual.cumulative_duration)
- self.assertEquals(expected.packet_rate, actual.packet_rate)
+ self.assertEqual(expected_details, actual_details)
+ self.assertEqual(expected.cumulative_duration, actual.cumulative_duration)
+ self.assertEqual(expected.packet_rate, actual.packet_rate)
with open(expected_fn) as f1, open(output) as f2:
expected_json = json.load(f1)
self.check_run(command)
expected = open(EXPECTED_FN).readlines()
actual = open(output).readlines()
- self.assertEquals(expected, actual)
+ self.assertEqual(expected, actual)
class CommonTests(samba.tests.TestCaseInTempDir):
def test_normalise_int32(self):
- self.assertEquals('17', normalise_int32(17))
- self.assertEquals('17', normalise_int32('17'))
- self.assertEquals('-123', normalise_int32('-123'))
- self.assertEquals('-1294967296', normalise_int32('3000000000'))
+ self.assertEqual('17', normalise_int32(17))
+ self.assertEqual('17', normalise_int32('17'))
+ self.assertEqual('-123', normalise_int32('-123'))
+ self.assertEqual('-1294967296', normalise_int32('3000000000'))
def test_dsdb_Dn_binary(self):
url = self.tempdir + "/test_dsdb_Dn_binary.ldb"
sam = samba.Ldb(url=url)
dn1 = dsdb_Dn(sam, "DC=foo,DC=bar")
dn2 = dsdb_Dn(sam, "B:8:0000000D:<GUID=b3f0ec29-17f4-452a-b002-963e1909d101>;DC=samba,DC=example,DC=com")
- self.assertEquals(dn2.binary, "0000000D")
- self.assertEquals(13, dn2.get_binary_integer())
+ self.assertEqual(dn2.binary, "0000000D")
+ self.assertEqual(13, dn2.get_binary_integer())
os.unlink(url)
def test_dsdb_Dn_sorted(self):
dn6 = dsdb_Dn(sam, "<GUID=00000000-27f4-452a-b002-963e1909d101>;OU=dn6,DC=samba,DC=example,DC=com")
unsorted_links14 = [dn1, dn2, dn3, dn4]
sorted_vals14 = [str(dn) for dn in sorted(unsorted_links14)]
- self.assertEquals(sorted_vals14[0], str(dn3))
- self.assertEquals(sorted_vals14[1], str(dn2))
- self.assertEquals(sorted_vals14[2], str(dn1))
- self.assertEquals(sorted_vals14[3], str(dn4))
+ self.assertEqual(sorted_vals14[0], str(dn3))
+ self.assertEqual(sorted_vals14[1], str(dn2))
+ self.assertEqual(sorted_vals14[2], str(dn1))
+ self.assertEqual(sorted_vals14[3], str(dn4))
unsorted_links56 = [dn5, dn6]
sorted_vals56 = [str(dn) for dn in sorted(unsorted_links56)]
- self.assertEquals(sorted_vals56[0], str(dn6))
- self.assertEquals(sorted_vals56[1], str(dn5))
+ self.assertEqual(sorted_vals56[0], str(dn6))
+ self.assertEqual(sorted_vals56[1], str(dn5))
finally:
del sam
os.unlink(url)
class SubstituteVarTestCase(TestCase):
def test_empty(self):
- self.assertEquals("", samba.substitute_var("", {}))
+ self.assertEqual("", samba.substitute_var("", {}))
def test_nothing(self):
- self.assertEquals("foo bar",
+ self.assertEqual("foo bar",
samba.substitute_var("foo bar", {"bar": "bla"}))
def test_replace(self):
- self.assertEquals("foo bla",
+ self.assertEqual("foo bla",
samba.substitute_var("foo ${bar}", {"bar": "bla"}))
def test_broken(self):
- self.assertEquals("foo ${bdkjfhsdkfh sdkfh ",
+ self.assertEqual("foo ${bdkjfhsdkfh sdkfh ",
samba.substitute_var("foo ${bdkjfhsdkfh sdkfh ", {"bar": "bla"}))
def test_unknown_var(self):
- self.assertEquals("foo ${bla} gsff",
+ self.assertEqual("foo ${bla} gsff",
samba.substitute_var("foo ${bla} gsff", {"bar": "bla"}))
def test_check_all_substituted(self):
plain = b'abcdefghi'
crypt_expected = b'\xda\x91Z\xb0l\xd7\xb9\xcf\x99'
crypt_calculated = arcfour_encrypt(key, plain)
- self.assertEquals(crypt_expected, crypt_calculated)
+ self.assertEqual(crypt_expected, crypt_calculated)
class StringToByteArrayTestCase(TestCase):
def test_byte_array(self):
expected = [218, 145, 90, 176, 108, 215, 185, 207, 153]
calculated = string_to_byte_array('\xda\x91Z\xb0l\xd7\xb9\xcf\x99')
- self.assertEquals(expected, calculated)
+ self.assertEqual(expected, calculated)
class LdbExtensionTests(TestCaseInTempDir):
l = samba.Ldb(path)
try:
l.add({"dn": "foo=dc", "bar": "bla"})
- self.assertEquals(b"bla",
+ self.assertEqual(b"bla",
l.searchone(basedn=ldb.Dn(l, "foo=dc"), attribute="bar"))
finally:
del l
x = ClientConnection("ncalrpc:localhost[DEFAULT]",
("60a15ec5-4de8-11d7-a637-005056a20182", 1),
lp_ctx=samba.tests.env_loadparm())
- self.assertEquals(b"\x01\x00\x00\x00", x.request(0, chr(0) * 4))
+ self.assertEqual(b"\x01\x00\x00\x00", x.request(0, chr(0) * 4))
def test_two_contexts(self):
x = ClientConnection("ncalrpc:localhost[DEFAULT]",
y = ClientConnection("ncalrpc:localhost",
("60a15ec5-4de8-11d7-a637-005056a20182", 1),
basis_connection=x, lp_ctx=samba.tests.env_loadparm())
- self.assertEquals(24, len(x.request(0, chr(0) * 8)))
- self.assertEquals(b"\x01\x00\x00\x00", y.request(0, chr(0) * 4))
+ self.assertEqual(24, len(x.request(0, chr(0) * 8)))
+ self.assertEqual(b"\x01\x00\x00\x00", y.request(0, chr(0) * 4))
def test_bare_tcp(self):
# Connect to the echo pipe
x = ClientConnection("ncacn_ip_tcp:%s" % os.environ["SERVER"],
("60a15ec5-4de8-11d7-a637-005056a20182", 1),
lp_ctx=samba.tests.env_loadparm())
- self.assertEquals(b"\x01\x00\x00\x00", x.request(0, chr(0) * 4))
+ self.assertEqual(b"\x01\x00\x00\x00", x.request(0, chr(0) * 4))
def test_two_contexts_tcp(self):
x = ClientConnection("ncacn_ip_tcp:%s" % os.environ["SERVER"],
y = ClientConnection("ncacn_ip_tcp:%s" % os.environ["SERVER"],
("60a15ec5-4de8-11d7-a637-005056a20182", 1),
basis_connection=x, lp_ctx=samba.tests.env_loadparm())
- self.assertEquals(24, len(x.request(0, chr(0) * 8)))
- self.assertEquals(b"\x01\x00\x00\x00", y.request(0, chr(0) * 4))
+ self.assertEqual(24, len(x.request(0, chr(0) * 8)))
+ self.assertEqual(b"\x01\x00\x00\x00", y.request(0, chr(0) * 4))
self.server,
None,
'ServerInfo')
- self.assertEquals(dnsserver.DNSSRV_TYPEID_SERVER_INFO_W2K, typeid)
+ self.assertEqual(dnsserver.DNSSRV_TYPEID_SERVER_INFO_W2K, typeid)
typeid, result = self.conn.DnssrvQuery2(dnsserver.DNS_CLIENT_VERSION_DOTNET,
0,
self.server,
None,
'ServerInfo')
- self.assertEquals(dnsserver.DNSSRV_TYPEID_SERVER_INFO_DOTNET, typeid)
+ self.assertEqual(dnsserver.DNSSRV_TYPEID_SERVER_INFO_DOTNET, typeid)
typeid, result = self.conn.DnssrvQuery2(dnsserver.DNS_CLIENT_VERSION_LONGHORN,
0,
self.server,
None,
'ServerInfo')
- self.assertEquals(dnsserver.DNSSRV_TYPEID_SERVER_INFO, typeid)
+ self.assertEqual(dnsserver.DNSSRV_TYPEID_SERVER_INFO, typeid)
# This test is to confirm that we do not support multizone operations,
'EnumZones',
dnsserver.DNSSRV_TYPEID_DWORD,
request_filter)
- self.assertEquals(1, zones.dwZoneCount)
+ self.assertEqual(1, zones.dwZoneCount)
# Delete zone
self.conn.DnssrvOperation2(client_version,
'EnumZones',
dnsserver.DNSSRV_TYPEID_DWORD,
request_filter)
- self.assertEquals(0, zones.dwZoneCount)
+ self.assertEqual(0, zones.dwZoneCount)
def test_complexoperation2(self):
client_version = dnsserver.DNS_CLIENT_VERSION_LONGHORN
'EnumZones',
dnsserver.DNSSRV_TYPEID_DWORD,
request_filter)
- self.assertEquals(dnsserver.DNSSRV_TYPEID_ZONE_LIST, typeid)
- self.assertEquals(3, zones.dwZoneCount)
+ self.assertEqual(dnsserver.DNSSRV_TYPEID_ZONE_LIST, typeid)
+ self.assertEqual(3, zones.dwZoneCount)
request_filter = (dnsserver.DNS_ZONE_REQUEST_REVERSE |
dnsserver.DNS_ZONE_REQUEST_PRIMARY)
'EnumZones',
dnsserver.DNSSRV_TYPEID_DWORD,
request_filter)
- self.assertEquals(dnsserver.DNSSRV_TYPEID_ZONE_LIST, typeid)
- self.assertEquals(0, zones.dwZoneCount)
+ self.assertEqual(dnsserver.DNSSRV_TYPEID_ZONE_LIST, typeid)
+ self.assertEqual(0, zones.dwZoneCount)
def test_enumrecords2(self):
client_version = dnsserver.DNS_CLIENT_VERSION_LONGHORN
select_flags,
None,
None)
- self.assertEquals(14, roothints.count) # 1 NS + 13 A records (a-m)
+ self.assertEqual(14, roothints.count) # 1 NS + 13 A records (a-m)
def test_updaterecords2(self):
client_version = dnsserver.DNS_CLIENT_VERSION_LONGHORN
select_flags,
None,
None)
- self.assertEquals(1, result.count)
- self.assertEquals(1, result.rec[0].wRecordCount)
- self.assertEquals(dnsp.DNS_TYPE_A, result.rec[0].records[0].wType)
- self.assertEquals('1.2.3.4', result.rec[0].records[0].data)
+ self.assertEqual(1, result.count)
+ self.assertEqual(1, result.rec[0].wRecordCount)
+ self.assertEqual(dnsp.DNS_TYPE_A, result.rec[0].records[0].wType)
+ self.assertEqual('1.2.3.4', result.rec[0].records[0].data)
# Update record
add_rec_buf = dnsserver.DNS_RPC_RECORD_BUF()
select_flags,
None,
None)
- self.assertEquals(1, result.count)
- self.assertEquals(1, result.rec[0].wRecordCount)
- self.assertEquals(dnsp.DNS_TYPE_A, result.rec[0].records[0].wType)
- self.assertEquals('5.6.7.8', result.rec[0].records[0].data)
+ self.assertEqual(1, result.count)
+ self.assertEqual(1, result.rec[0].wRecordCount)
+ self.assertEqual(dnsp.DNS_TYPE_A, result.rec[0].records[0].wType)
+ self.assertEqual('5.6.7.8', result.rec[0].records[0].data)
# Delete record
del_rec_buf = dnsserver.DNS_RPC_RECORD_BUF()
def test_uint32_into_hyper(self):
s = server_id.server_id()
s.unique_id = server_id.NONCLUSTER_VNN
- self.assertEquals(s.unique_id, 0xFFFFFFFF)
+ self.assertEqual(s.unique_id, 0xFFFFFFFF)
def test_int_into_hyper(self):
s = server_id.server_id()
s.unique_id = 1
- self.assertEquals(s.unique_id, 1)
+ self.assertEqual(s.unique_id, 1)
def test_negative_int_into_hyper(self):
s = server_id.server_id()
def test_int_into_int32(self):
s = srvsvc.NetRemoteTODInfo()
s.timezone = 5
- self.assertEquals(s.timezone, 5)
+ self.assertEqual(s.timezone, 5)
def test_uint32_into_int32(self):
s = srvsvc.NetRemoteTODInfo()
# s.timezone = 5L
# but that is a syntax error in py3.
s.timezone = (5 << 65) >> 65
- self.assertEquals(s.timezone, 5)
+ self.assertEqual(s.timezone, 5)
def test_larger_long_int_into_int32(self):
s = srvsvc.NetRemoteTODInfo()
def test_larger_int_into_int32(self):
s = srvsvc.NetRemoteTODInfo()
s.timezone = 2147483647
- self.assertEquals(s.timezone, 2147483647)
+ self.assertEqual(s.timezone, 2147483647)
def test_float_into_int32(self):
s = srvsvc.NetRemoteTODInfo()
def test_negative_int_into_int32(self):
s = srvsvc.NetRemoteTODInfo()
s.timezone = -2147483648
- self.assertEquals(s.timezone, -2147483648)
+ self.assertEqual(s.timezone, -2147483648)
def test_negative_into_uint32(self):
s = server_id.server_id()
def test_enum_into_uint16(self):
g = misc.GUID()
g.time_mid = misc.SEC_CHAN_DOMAIN
- self.assertEquals(g.time_mid, misc.SEC_CHAN_DOMAIN)
+ self.assertEqual(g.time_mid, misc.SEC_CHAN_DOMAIN)
def test_bitmap_into_uint16(self):
g = misc.GUID()
def test_int_into_int64(self):
s = samr.DomInfo1()
s.max_password_age = 5
- self.assertEquals(s.max_password_age, 5)
+ self.assertEqual(s.max_password_age, 5)
def test_negative_int_into_int64(self):
s = samr.DomInfo1()
s.max_password_age = -5
- self.assertEquals(s.max_password_age, -5)
+ self.assertEqual(s.max_password_age, -5)
def test_larger_int_into_int64(self):
s = samr.DomInfo1()
s.max_password_age = server_id.NONCLUSTER_VNN
- self.assertEquals(s.max_password_age, 0xFFFFFFFF)
+ self.assertEqual(s.max_password_age, 0xFFFFFFFF)
def test_larger_negative_int_into_int64(self):
s = samr.DomInfo1()
s.max_password_age = -2147483649
- self.assertEquals(s.max_password_age, -2147483649)
+ self.assertEqual(s.max_password_age, -2147483649)
def test_int_list_over_list(self):
g = misc.GUID()
time.sleep(1)
results = search.get_results(self.pipe)
- self.assertEquals(results, expect)
+ self.assertEqual(results, expect)
search.close(self.pipe)
self.conn.disconnect(self.pipe)
def test_str(self):
guid = misc.GUID(text1)
- self.assertEquals(text1, str(guid))
+ self.assertEqual(text1, str(guid))
def test_repr(self):
guid = misc.GUID(text1)
- self.assertEquals("GUID('%s')" % text1, repr(guid))
+ self.assertEqual("GUID('%s')" % text1, repr(guid))
def test_compare_different(self):
guid1 = misc.GUID(text1)
guid1 = misc.GUID(text1)
guid2 = misc.GUID(text1)
self.assertTrue(guid1 == guid2)
- self.assertEquals(guid1, guid2)
- self.assertEquals(0, cmp(guid1, guid2))
+ self.assertEqual(guid1, guid2)
+ self.assertEqual(0, cmp(guid1, guid2))
def test_valid_formats(self):
fmts = [
]
for fmt in fmts:
guid = misc.GUID(fmt)
- self.assertEquals(text3, str(guid))
+ self.assertEqual(text3, str(guid))
def test_invalid_formats(self):
fmts = [
def test_init(self):
x = misc.policy_handle(text1, 1)
- self.assertEquals(1, x.handle_type)
- self.assertEquals(text1, str(x.uuid))
+ self.assertEqual(1, x.handle_type)
+ self.assertEqual(text1, str(x.uuid))
def test_repr(self):
x = misc.policy_handle(text1, 42)
- self.assertEquals("policy_handle(%d, '%s')" % (42, text1), repr(x))
+ self.assertEqual("policy_handle(%d, '%s')" % (42, text1), repr(x))
def test_str(self):
x = misc.policy_handle(text1, 42)
- self.assertEquals("%d, %s" % (42, text1), str(x))
+ self.assertEqual("%d, %s" % (42, text1), str(x))
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
pfc_flags=rep_pfc_flags, auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
# And now try a request
req = self.generate_request(call_id=1,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
def _test_no_auth_request_alter_pfc_flags(self, req_pfc_flags, rep_pfc_flags):
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
# And now try a alter context
req = self.generate_alter(call_id=0, pfc_flags=req_pfc_flags, ctx_list=[ctx1])
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
pfc_flags=rep_pfc_flags, auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
- self.assertEquals(rep.u.secondary_address, "")
+ self.assertEqual(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address, "")
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
# And now try a request
req = self.generate_request(call_id=1,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
def test_no_auth_request(self):
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.reject_reason,
+ self.assertEqual(rep.u.reject_reason,
dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
- self.assertEquals(rep.u.num_versions, 1)
- self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
- self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
+ self.assertEqual(rep.u.num_versions, 1)
+ self.assertEqual(rep.u.versions[0].rpc_vers, req.rpc_vers)
+ self.assertEqual(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.assertPadding(rep.u._pad, 3)
def test_invalid_auth_noctx(self):
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.reject_reason,
+ self.assertEqual(rep.u.reject_reason,
dcerpc.DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED)
- self.assertEquals(rep.u.num_versions, 1)
- self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
- self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
+ self.assertEqual(rep.u.num_versions, 1)
+ self.assertEqual(rep.u.versions[0].rpc_vers, req.rpc_vers)
+ self.assertEqual(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.assertPadding(rep.u._pad, 3)
def test_no_auth_valid_valid_request(self):
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
# Send a bind again
tsf2_list = [ndr32]
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.reject_reason,
+ self.assertEqual(rep.u.reject_reason,
dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
- self.assertEquals(rep.u.num_versions, 1)
- self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
- self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
+ self.assertEqual(rep.u.num_versions, 1)
+ self.assertEqual(rep.u.versions[0].rpc_vers, req.rpc_vers)
+ self.assertEqual(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.assertPadding(rep.u._pad, 3)
# wait for a disconnect
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.reject_reason,
+ self.assertEqual(rep.u.reject_reason,
dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
- self.assertEquals(rep.u.num_versions, 1)
- self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
- self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
+ self.assertEqual(rep.u.num_versions, 1)
+ self.assertEqual(rep.u.versions[0].rpc_vers, req.rpc_vers)
+ self.assertEqual(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.assertPadding(rep.u._pad, 3)
# wait for a disconnect
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
# Send a alter
req = self.generate_alter(call_id=1, ctx_list=[])
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
# Send a alter
req = self.generate_alter(call_id=1, ctx_list=[ctx1])
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
req = self.generate_request(call_id=2,
context_id=ctx1.context_id,
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, ctx1.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_OP_RNG_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, ctx1.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_OP_RNG_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
def test_no_auth_presentation_ctx_invalid1(self):
ndr32 = base.transfer_syntax_ndr()
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
# Send a alter
req = self.generate_alter(call_id=1, ctx_list=[ctx1])
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
req = self.generate_request(call_id=2,
context_id=12345,
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_UNKNOWN_IF)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_UNKNOWN_IF)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# Send a alter again to prove the connection is still alive
req = self.generate_alter(call_id=3, ctx_list=[ctx1])
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
def test_no_auth_presentation_ctx_invalid2(self):
ndr32 = base.transfer_syntax_ndr()
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.reject_reason,
+ self.assertEqual(rep.u.reject_reason,
dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
- self.assertEquals(rep.u.num_versions, 1)
- self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
- self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
+ self.assertEqual(rep.u.num_versions, 1)
+ self.assertEqual(rep.u.versions[0].rpc_vers, req.rpc_vers)
+ self.assertEqual(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.assertPadding(rep.u._pad, 3)
# wait for a disconnect
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
tsf1b_list = []
ctx1b = dcerpc.ctx_list()
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
# With a known but wrong syntax we get a protocol error
# see test_no_auth_presentation_ctx_valid2
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
# With a unknown but wrong syntaxes we get NO protocol error
# see test_no_auth_presentation_ctx_invalid4
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
req = self.generate_request(call_id=2,
context_id=ctx1a.context_id,
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, ctx1a.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_OP_RNG_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, ctx1a.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_OP_RNG_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
def test_no_auth_presentation_ctx_no_ndr64(self):
ndr32 = base.transfer_syntax_ndr()
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
tsf0_list = [ndr32]
ctx0 = dcerpc.ctx_list()
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
req = self.generate_request(call_id=1,
context_id=ctx0.context_id,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
tsf1_list = [zero_syntax, ndr32]
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
req = self.generate_request(call_id=1,
context_id=ctx1.context_id,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
tsf2_list = [ndr32, ndr32]
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
req = self.generate_request(call_id=1,
context_id=ctx2.context_id,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
tsf3_list = [ndr32]
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 2)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 2)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.ctx_list[1].result,
+ self.assertEqual(rep.u.ctx_list[1].result,
dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
- self.assertEquals(rep.u.ctx_list[1].reason,
+ self.assertEqual(rep.u.ctx_list[1].reason,
dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
req = self.generate_request(call_id=1,
context_id=ctx3.context_id,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
req = self.generate_alter(call_id=43, ctx_list=[ctx4, ctx3])
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 2)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 2)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.ctx_list[1].result,
+ self.assertEqual(rep.u.ctx_list[1].result,
dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
- self.assertEquals(rep.u.ctx_list[1].reason,
+ self.assertEqual(rep.u.ctx_list[1].reason,
dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
req = self.generate_request(call_id=1,
context_id=ctx4.context_id,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
req = self.generate_request(call_id=1,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
req = self.generate_alter(call_id=44, ctx_list=[ctx4, ctx4])
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 2)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 2)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.ctx_list[1].result,
+ self.assertEqual(rep.u.ctx_list[1].result,
dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
- self.assertEquals(rep.u.ctx_list[1].reason,
+ self.assertEqual(rep.u.ctx_list[1].reason,
dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
req = self.generate_request(call_id=1,
context_id=ctx4.context_id,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
req = self.generate_request(call_id=1,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
tsf5mgmt_list = [ndr32]
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 2)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 2)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.ctx_list[1].result,
+ self.assertEqual(rep.u.ctx_list[1].result,
dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
- self.assertEquals(rep.u.ctx_list[1].reason,
+ self.assertEqual(rep.u.ctx_list[1].reason,
dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
req = self.generate_request(call_id=1,
context_id=ctx5mgmt.context_id,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
req = self.generate_alter(call_id=55, ctx_list=[ctx5mgmt, ctx5epm])
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 2)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 2)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.ctx_list[1].result,
+ self.assertEqual(rep.u.ctx_list[1].result,
dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
- self.assertEquals(rep.u.ctx_list[1].reason,
+ self.assertEqual(rep.u.ctx_list[1].reason,
dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
req = self.generate_request(call_id=1,
context_id=ctx5mgmt.context_id,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
def test_no_auth_bind_time_none_simple(self):
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
- self.assertEquals(rep.u.ctx_list[0].reason, features)
+ self.assertEqual(rep.u.ctx_list[0].reason, features)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
def test_no_auth_bind_time_none_ignore_additional(self):
features1 = 0
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
- self.assertEquals(rep.u.ctx_list[0].reason, features1)
+ self.assertEqual(rep.u.ctx_list[0].reason, features1)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
def test_no_auth_bind_time_only_first(self):
features1 = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
def test_no_auth_bind_time_twice(self):
features1 = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.reject_reason,
+ self.assertEqual(rep.u.reject_reason,
dcerpc.DCERPC_BIND_NAK_REASON_NOT_SPECIFIED)
- self.assertEquals(rep.u.num_versions, 1)
- self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
- self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
+ self.assertEqual(rep.u.num_versions, 1)
+ self.assertEqual(rep.u.versions[0].rpc_vers, req.rpc_vers)
+ self.assertEqual(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.assertPadding(rep.u._pad, 3)
# wait for a disconnect
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
- self.assertEquals(rep.u.ctx_list[0].reason, features)
+ self.assertEqual(rep.u.ctx_list[0].reason, features)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
def test_no_auth_bind_time_keep_on_orphan_ignore_additional(self):
features1 = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
- self.assertEquals(rep.u.ctx_list[0].reason, features1)
+ self.assertEqual(rep.u.ctx_list[0].reason, features1)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
def test_no_auth_bind_time_sec_ctx_ignore_additional(self):
features1 = dcerpc.DCERPC_BIND_TIME_SECURITY_CONTEXT_MULTIPLEXING
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
- self.assertEquals(rep.u.ctx_list[0].reason, features1)
+ self.assertEqual(rep.u.ctx_list[0].reason, features1)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
def _test_auth_type_level_bind_nak(self, auth_type, auth_level, creds=None,
reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE):
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.reject_reason, reason)
- self.assertEquals(rep.u.num_versions, 1)
- self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
- self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
+ self.assertEqual(rep.u.reject_reason, reason)
+ self.assertEqual(rep.u.num_versions, 1)
+ self.assertEqual(rep.u.versions[0].rpc_vers, req.rpc_vers)
+ self.assertEqual(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.assertPadding(rep.u._pad, 3)
# wait for a disconnect
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(len(rep.u.auth_info), 0)
+ self.assertEqual(len(rep.u.auth_info), 0)
# And now try a request without auth_info
req = self.generate_request(call_id=2,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
auth_info = self.generate_auth(auth_type=auth_type,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, rep_both)
- self.assertEquals(rep.u.max_recv_frag, rep_both)
+ self.assertEqual(rep.u.max_xmit_frag, rep_both)
+ self.assertEqual(rep.u.max_recv_frag, rep_both)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
assoc_group_id = rep.u.assoc_group_id
if alter_xmit is None:
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, rep_both)
- self.assertEquals(rep.u.max_recv_frag, rep_both)
- self.assertEquals(rep.u.assoc_group_id, rep.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.max_xmit_frag, rep_both)
+ self.assertEqual(rep.u.max_recv_frag, rep_both)
+ self.assertEqual(rep.u.assoc_group_id, rep.u.assoc_group_id)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
chunk_size = rep_both - dcerpc.DCERPC_REQUEST_LENGTH
req = self.generate_request(call_id=2,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
chunk_size = 5840 - dcerpc.DCERPC_REQUEST_LENGTH
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
chunk_size += 1
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
- self.assertEquals(rep.u.auth_info, b'\0' * 0)
+ self.assertEqual(rep.u.auth_info, b'\0' * 0)
# And now try a request without auth_info
req = self.generate_request(call_id=2,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
req = self.generate_request(call_id=3,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
req = self.generate_request(call_id=4,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
def _get_netlogon_ctx(self):
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, fault_first)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, fault_first)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, fault_last)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, fault_last)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, fault_last)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, fault_last)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- self.assertEquals(len(rep.u.stub_and_verifier), 12)
+ self.assertEqual(len(rep.u.stub_and_verifier), 12)
status = struct.unpack_from("<I", rep.u.stub_and_verifier, len(rep.u.stub_and_verifier) - 4)
- self.assertEquals(status[0], 0)
+ self.assertEqual(status[0], 0)
def test_fragmented_requests01(self):
return self._test_fragmented_requests(remaining=0x400000,
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_NO_CALL_ACTIVE)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_FAULT_NO_CALL_ACTIVE)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- self.assertEquals(len(rep.u.stub_and_verifier), 12)
+ self.assertEqual(len(rep.u.stub_and_verifier), 12)
status = struct.unpack_from("<I", rep.u.stub_and_verifier, len(rep.u.stub_and_verifier) - 4)
- self.assertEquals(status[0], 0)
+ self.assertEqual(status[0], 0)
def test_last_cancel_requests(self):
(ctx, rep, real_stub) = self._get_netlogon_ctx()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- self.assertEquals(len(rep.u.stub_and_verifier), 12)
+ self.assertEqual(len(rep.u.stub_and_verifier), 12)
status = struct.unpack_from("<I", rep.u.stub_and_verifier, len(rep.u.stub_and_verifier) - 4)
- self.assertEquals(status[0], 0)
+ self.assertEqual(status[0], 0)
def test_mix_requests(self):
(ctx, rep, real_stub) = self._get_netlogon_ctx()
dcerpc.DCERPC_PFC_FLAG_LAST,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
def test_co_cancel_no_request(self):
ndr32 = base.transfer_syntax_ndr()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
def test_co_cancel_request_after_first(self):
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# And now try a request
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
def test_orphaned_no_request(self):
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id & 0xff)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
def test_orphaned_request_after_first_last(self):
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id & 0xff)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# And now try a request
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id & 0xff)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
def test_orphaned_request_after_first_mpx_last(self):
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id & 0xff)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# And now try a request
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id & 0xff)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
def test_orphaned_request_after_first_no_last(self):
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req1.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req1.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, req1.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req2.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
- self.assertEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.assoc_group_id, req.u.assoc_group_id)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id & 0xff)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id & 0xff)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# Now a request with auth_info upgrade_auth_level
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
- self.assertEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.assoc_group_id, req.u.assoc_group_id)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
assoc_group_id = rep.u.assoc_group_id
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
- self.assertEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.assoc_group_id, req.u.assoc_group_id)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id & 0xff)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# Now a reauth
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
- self.assertEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.assoc_group_id, req.u.assoc_group_id)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# Now a reauth
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_FAULT_SEC_PKG_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_FAULT_ACCESS_DENIED)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
- self.assertEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.assoc_group_id, req.u.assoc_group_id)
+ self.assertEqual(rep.u.secondary_address_size, 0)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
self._disconnect("disconnect")
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.reject_reason,
+ self.assertEqual(rep.u.reject_reason,
dcerpc.DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED)
- self.assertEquals(rep.u.num_versions, 1)
- self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
- self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
- self.assertEquals(len(rep.u._pad), 3)
- self.assertEquals(rep.u._pad, b'\0' * 3)
+ self.assertEqual(rep.u.num_versions, 1)
+ self.assertEqual(rep.u.versions[0].rpc_vers, req.rpc_vers)
+ self.assertEqual(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
+ self.assertEqual(len(rep.u._pad), 3)
+ self.assertEqual(rep.u._pad, b'\0' * 3)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_PROTO_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
# Now a request with auth_info DCERPC_AUTH_LEVEL_CONNECT
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
self._disconnect("disconnect")
self.send_pdu(req)
rep = self.recv_pdu()
self.verify_pdu(rep, dcerpc.DCERPC_PKT_BIND_ACK, req.call_id)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
self.assertNotEquals(rep.u.assoc_group_id, req.u.assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 4)
- self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
+ self.assertEqual(rep.u.secondary_address_size, 4)
+ self.assertEqual(rep.u.secondary_address, "%d" % self.tcp_port)
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
self.assertNotEquals(len(rep.u.auth_info), 0)
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
# wait for a disconnect
rep = self.recv_pdu()
pfc_flags=req.pfc_flags | response_fault_flags,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, ctx1.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, request_fault)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, ctx1.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, request_fault)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
if response_fault_flags & dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE:
return
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=sig_size)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id & 0xff)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- self.assertEquals(rep.auth_length, sig_size)
+ self.assertEqual(rep.auth_length, sig_size)
ofs_stub = dcerpc.DCERPC_REQUEST_LENGTH
ofs_sig = rep.frag_length - rep.auth_length
rep_auth_info_blob = rep_blob[ofs_trailer:]
rep_auth_info = self.parse_auth(rep_auth_info_blob)
- self.assertEquals(rep_auth_info.auth_type, auth_type)
- self.assertEquals(rep_auth_info.auth_level, auth_level)
+ self.assertEqual(rep_auth_info.auth_type, auth_type)
+ self.assertEqual(rep_auth_info.auth_level, auth_level)
# mgmt_inq_if_ids() returns no fixed size results
- #self.assertEquals(rep_auth_info.auth_pad_length, 0)
- self.assertEquals(rep_auth_info.auth_reserved, 0)
- self.assertEquals(rep_auth_info.auth_context_id, auth_context_id)
- self.assertEquals(rep_auth_info.credentials, rep_sig)
+ #self.assertEqual(rep_auth_info.auth_pad_length, 0)
+ self.assertEqual(rep_auth_info.auth_reserved, 0)
+ self.assertEqual(rep_auth_info.auth_context_id, auth_context_id)
+ self.assertEqual(rep_auth_info.credentials, rep_sig)
g.check_packet(rep_data, rep_whole, rep_sig)
dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, ctx1.context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, dcerpc.DCERPC_NCA_S_OP_RNG_ERROR)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, ctx1.context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, dcerpc.DCERPC_NCA_S_OP_RNG_ERROR)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
stub_bin = b'\x00' * 8
mod_len = len(stub_bin) % dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=sig_size)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id & 0xff)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- self.assertEquals(rep.auth_length, sig_size)
+ self.assertEqual(rep.auth_length, sig_size)
ofs_stub = dcerpc.DCERPC_REQUEST_LENGTH
ofs_sig = rep.frag_length - rep.auth_length
rep_auth_info_blob = rep_blob[ofs_trailer:]
rep_auth_info = self.parse_auth(rep_auth_info_blob)
- self.assertEquals(rep_auth_info.auth_type, auth_type)
- self.assertEquals(rep_auth_info.auth_level, auth_level)
- self.assertEquals(rep_auth_info.auth_pad_length, 4)
- self.assertEquals(rep_auth_info.auth_reserved, 0)
- self.assertEquals(rep_auth_info.auth_context_id, auth_context_id)
- self.assertEquals(rep_auth_info.credentials, rep_sig)
+ self.assertEqual(rep_auth_info.auth_type, auth_type)
+ self.assertEqual(rep_auth_info.auth_level, auth_level)
+ self.assertEqual(rep_auth_info.auth_pad_length, 4)
+ self.assertEqual(rep_auth_info.auth_reserved, 0)
+ self.assertEqual(rep_auth_info.auth_context_id, auth_context_id)
+ self.assertEqual(rep_auth_info.credentials, rep_sig)
g.check_packet(rep_data, rep_whole, rep_sig)
self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=sig_size)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id & 0xff)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
- self.assertEquals(rep.auth_length, sig_size)
+ self.assertEqual(rep.auth_length, sig_size)
ofs_stub = dcerpc.DCERPC_REQUEST_LENGTH
ofs_sig = rep.frag_length - rep.auth_length
rep_auth_info_blob = rep_blob[ofs_trailer:]
rep_auth_info = self.parse_auth(rep_auth_info_blob)
- self.assertEquals(rep_auth_info.auth_type, auth_type)
- self.assertEquals(rep_auth_info.auth_level, auth_level)
- self.assertEquals(rep_auth_info.auth_pad_length, 12)
- self.assertEquals(rep_auth_info.auth_reserved, 0)
- self.assertEquals(rep_auth_info.auth_context_id, auth_context_id)
- self.assertEquals(rep_auth_info.credentials, rep_sig)
+ self.assertEqual(rep_auth_info.auth_type, auth_type)
+ self.assertEqual(rep_auth_info.auth_level, auth_level)
+ self.assertEqual(rep_auth_info.auth_pad_length, 12)
+ self.assertEqual(rep_auth_info.auth_reserved, 0)
+ self.assertEqual(rep_auth_info.auth_context_id, auth_context_id)
+ self.assertEqual(rep_auth_info.credentials, rep_sig)
g.check_packet(rep_data, rep_whole, rep_sig)
def _connect_smb(self):
a = self.primary_address.split('\\')
- self.assertEquals(len(a), 3)
- self.assertEquals(a[0], "")
- self.assertEquals(a[1], "pipe")
+ self.assertEqual(len(a), 3)
+ self.assertEqual(a[0], "")
+ self.assertEqual(a[1], "pipe")
pipename = a[2]
self.s = smb_pipe_socket(self.target_hostname,
pipename,
samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, alter_fault)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, alter_fault)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
return None
self.verify_pdu(rep, samba.dcerpc.dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
pfc_flags=req.pfc_flags)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
- self.assertEquals(rep.u.assoc_group_id, assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
- self.assertEquals(rep.u.secondary_address, '')
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.assoc_group_id, assoc_group_id)
+ self.assertEqual(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address, '')
self.assertPadding(rep.u._pad1, 2)
else:
req = self.generate_bind(call_id=call_id,
if nak_reason is not None:
self.verify_pdu(rep, samba.dcerpc.dcerpc.DCERPC_PKT_BIND_NAK, req.call_id,
auth_length=0)
- self.assertEquals(rep.u.reject_reason, nak_reason)
- self.assertEquals(rep.u.num_versions, 1)
- self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
- self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
+ self.assertEqual(rep.u.reject_reason, nak_reason)
+ self.assertEqual(rep.u.num_versions, 1)
+ self.assertEqual(rep.u.versions[0].rpc_vers, req.rpc_vers)
+ self.assertEqual(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
self.assertPadding(rep.u._pad, 3)
return
self.verify_pdu(rep, samba.dcerpc.dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
pfc_flags=pfc_flags)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
if assoc_group_id != 0:
- self.assertEquals(rep.u.assoc_group_id, assoc_group_id)
+ self.assertEqual(rep.u.assoc_group_id, assoc_group_id)
else:
self.assertNotEquals(rep.u.assoc_group_id, 0)
assoc_group_id = rep.u.assoc_group_id
sda_pad = 4 - mod_len
else:
sda_pad = 0
- self.assertEquals(rep.u.secondary_address_size, sda_len)
- self.assertEquals(rep.u.secondary_address, sda_str)
+ self.assertEqual(rep.u.secondary_address_size, sda_len)
+ self.assertEqual(rep.u.secondary_address, sda_str)
self.assertPadding(rep.u._pad1, sda_pad)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
samba.dcerpc.dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
samba.dcerpc.dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ctx.transfer_syntaxes[0])
ack = rep
if auth_context is None:
- self.assertEquals(rep.auth_length, 0)
- self.assertEquals(len(rep.u.auth_info), 0)
+ self.assertEqual(rep.auth_length, 0)
+ self.assertEqual(len(rep.u.auth_info), 0)
return ack
self.assertNotEquals(rep.auth_length, 0)
self.assertGreater(len(rep.u.auth_info), samba.dcerpc.dcerpc.DCERPC_AUTH_TRAILER_LENGTH)
- self.assertEquals(rep.auth_length, len(rep.u.auth_info) - samba.dcerpc.dcerpc.DCERPC_AUTH_TRAILER_LENGTH)
+ self.assertEqual(rep.auth_length, len(rep.u.auth_info) - samba.dcerpc.dcerpc.DCERPC_AUTH_TRAILER_LENGTH)
a = self.parse_auth(rep.u.auth_info, auth_context=auth_context)
samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_DID_NOT_EXECUTE,
auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, 0)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, alter_fault)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, 0)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, alter_fault)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
return None
self.verify_pdu(rep, samba.dcerpc.dcerpc.DCERPC_PKT_ALTER_RESP, req.call_id,
pfc_flags=req.pfc_flags)
- self.assertEquals(rep.u.max_xmit_frag, req.u.max_xmit_frag)
- self.assertEquals(rep.u.max_recv_frag, req.u.max_recv_frag)
- self.assertEquals(rep.u.assoc_group_id, assoc_group_id)
- self.assertEquals(rep.u.secondary_address_size, 0)
- self.assertEquals(rep.u.secondary_address, '')
+ self.assertEqual(rep.u.max_xmit_frag, req.u.max_xmit_frag)
+ self.assertEqual(rep.u.max_recv_frag, req.u.max_recv_frag)
+ self.assertEqual(rep.u.assoc_group_id, assoc_group_id)
+ self.assertEqual(rep.u.secondary_address_size, 0)
+ self.assertEqual(rep.u.secondary_address, '')
self.assertPadding(rep.u._pad1, 2)
- self.assertEquals(rep.u.num_results, 1)
- self.assertEquals(rep.u.ctx_list[0].result,
+ self.assertEqual(rep.u.num_results, 1)
+ self.assertEqual(rep.u.ctx_list[0].result,
samba.dcerpc.dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
- self.assertEquals(rep.u.ctx_list[0].reason,
+ self.assertEqual(rep.u.ctx_list[0].reason,
samba.dcerpc.dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ctx.transfer_syntaxes[0])
if finished:
- self.assertEquals(rep.auth_length, 0)
+ self.assertEqual(rep.auth_length, 0)
else:
self.assertNotEquals(rep.auth_length, 0)
self.assertGreaterEqual(len(rep.u.auth_info), samba.dcerpc.dcerpc.DCERPC_AUTH_TRAILER_LENGTH)
- self.assertEquals(rep.auth_length, len(rep.u.auth_info) - samba.dcerpc.dcerpc.DCERPC_AUTH_TRAILER_LENGTH)
+ self.assertEqual(rep.auth_length, len(rep.u.auth_info) - samba.dcerpc.dcerpc.DCERPC_AUTH_TRAILER_LENGTH)
a = self.parse_auth(rep.u.auth_info, auth_context=auth_context)
self.verify_pdu(rep, samba.dcerpc.dcerpc.DCERPC_PKT_FAULT, req.call_id,
pfc_flags=fault_pfc_flags, auth_length=0)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, fault_context_id)
- self.assertEquals(rep.u.cancel_count, 0)
- self.assertEquals(rep.u.flags, 0)
- self.assertEquals(rep.u.status, fault_status)
- self.assertEquals(rep.u.reserved, 0)
- self.assertEquals(len(rep.u.error_and_verifier), 0)
+ self.assertEqual(rep.u.context_id, fault_context_id)
+ self.assertEqual(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.flags, 0)
+ self.assertEqual(rep.u.status, fault_status)
+ self.assertEqual(rep.u.reserved, 0)
+ self.assertEqual(len(rep.u.error_and_verifier), 0)
return
expected_auth_length = 0
self.verify_pdu(rep, samba.dcerpc.dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
auth_length=expected_auth_length)
self.assertNotEquals(rep.u.alloc_hint, 0)
- self.assertEquals(rep.u.context_id, req.u.context_id & 0xff)
- self.assertEquals(rep.u.cancel_count, 0)
+ self.assertEqual(rep.u.context_id, req.u.context_id & 0xff)
+ self.assertEqual(rep.u.cancel_count, 0)
self.assertGreaterEqual(len(rep.u.stub_and_verifier), rep.u.alloc_hint)
stub_out = self.check_response_auth(rep, rep_blob, auth_context)
self.assertEqual(len(stub_out), rep.u.alloc_hint)
sys.stderr.write("parse_auth: %s" % samba.ndr.ndr_print(a))
if auth_context is not None:
- self.assertEquals(a.auth_type, auth_context["auth_type"])
- self.assertEquals(a.auth_level, auth_context["auth_level"])
- self.assertEquals(a.auth_reserved, 0)
- self.assertEquals(a.auth_context_id, auth_context["auth_context_id"])
+ self.assertEqual(a.auth_type, auth_context["auth_type"])
+ self.assertEqual(a.auth_level, auth_context["auth_level"])
+ self.assertEqual(a.auth_reserved, 0)
+ self.assertEqual(a.auth_context_id, auth_context["auth_context_id"])
self.assertLessEqual(a.auth_pad_length, dcerpc.DCERPC_AUTH_PAD_ALIGNMENT)
self.assertLessEqual(a.auth_pad_length, stub_len)
auth_pad_length=None):
if auth_context is None:
- self.assertEquals(rep.auth_length, 0)
+ self.assertEqual(rep.auth_length, 0)
return rep.u.stub_and_verifier
if auth_context["auth_level"] == dcerpc.DCERPC_AUTH_LEVEL_CONNECT:
- self.assertEquals(rep.auth_length, 0)
+ self.assertEqual(rep.auth_length, 0)
return rep.u.stub_and_verifier
self.assertGreater(rep.auth_length, 0)
auth_context=auth_context,
stub_len=len(rep_data))
if auth_pad_length is not None:
- self.assertEquals(rep_auth_info.auth_pad_length, auth_pad_length)
- self.assertEquals(rep_auth_info.credentials, rep_sig)
+ self.assertEqual(rep_auth_info.auth_pad_length, auth_pad_length)
+ self.assertEqual(rep_auth_info.credentials, rep_sig)
if auth_context["auth_level"] >= dcerpc.DCERPC_AUTH_LEVEL_PRIVACY:
# TODO: not yet supported here
elif auth_context["auth_level"] >= dcerpc.DCERPC_AUTH_LEVEL_PACKET:
req_sig = auth_context["gensec"].sign_packet(req_data, req_whole)
elif auth_context["auth_level"] >= dcerpc.DCERPC_AUTH_LEVEL_CONNECT:
- self.assertEquals(auth_context["auth_type"],
+ self.assertEqual(auth_context["auth_type"],
dcerpc.DCERPC_AUTH_TYPE_NTLMSSP)
req_sig = b"\x01" +b"\x00" *15
else:
return req
- self.assertEquals(len(req_sig), req.auth_length)
- self.assertEquals(len(req_sig), sig_size)
+ self.assertEqual(len(req_sig), req.auth_length)
+ self.assertEqual(len(req_sig), sig_size)
stub_sig_ofs = len(req.u.stub_and_verifier) - sig_size
stub = req.u.stub_and_verifier[0:stub_sig_ofs] + req_sig
return
def assertPadding(self, pad, length):
- self.assertEquals(len(pad), length)
+ self.assertEqual(len(pad), length)
#
# sometimes windows sends random bytes
#
if self.ignore_random_pad:
return
zero_pad = b'\0' * length
- self.assertEquals(pad, zero_pad)
+ self.assertEqual(pad, zero_pad)
def assertEqualsStrLower(self, s1, s2):
- self.assertEquals(str(s1).lower(), str(s2).lower())
+ self.assertEqual(str(s1).lower(), str(s2).lower())
def test_getversion(self):
handle = self.get_hklm()
version = self.conn.GetVersion(handle)
- self.assertEquals(int, version.__class__)
+ self.assertEqual(int, version.__class__)
self.conn.CloseKey(handle)
def test_getkeyinfo(self):
handle = self.conn.OpenHKLM(None,
winreg.KEY_QUERY_VALUE | winreg.KEY_ENUMERATE_SUB_KEYS)
x = self.conn.QueryInfoKey(handle, winreg.String())
- self.assertEquals(9, len(x)) # should return a 9-tuple
+ self.assertEqual(9, len(x)) # should return a 9-tuple
self.conn.CloseKey(handle)
nblocks = talloc.total_blocks(object)
if object is None:
nblocks -= self.initial_blocks
- self.assertEquals(nblocks, num_expected)
+ self.assertEqual(nblocks, num_expected)
def get_rodc_partial_attribute_set(self):
'''get a list of attributes for RODC replication'''
def test_two_contexts(self):
self.conn2 = echo.rpcecho("ncalrpc:", self.get_loadparm(), basis_connection=self.conn)
- self.assertEquals(3, self.conn2.AddOne(2))
+ self.assertEqual(3, self.conn2.AddOne(2))
def test_abstract_syntax(self):
- self.assertEquals(("60a15ec5-4de8-11d7-a637-005056a20182", 1),
+ self.assertEqual(("60a15ec5-4de8-11d7-a637-005056a20182", 1),
self.conn.abstract_syntax)
def test_addone(self):
- self.assertEquals(2, self.conn.AddOne(1))
+ self.assertEqual(2, self.conn.AddOne(1))
def test_echodata(self):
- self.assertEquals([1, 2, 3], self.conn.EchoData([1, 2, 3]))
+ self.assertEqual([1, 2, 3], self.conn.EchoData([1, 2, 3]))
def test_call(self):
- self.assertEquals(u"foobar", self.conn.TestCall(u"foobar"))
+ self.assertEqual(u"foobar", self.conn.TestCall(u"foobar"))
def test_surrounding(self):
surrounding_struct = echo.Surrounding()
surrounding_struct.x = 4
surrounding_struct.surrounding = [1, 2, 3, 4]
y = self.conn.TestSurrounding(surrounding_struct)
- self.assertEquals(8 * [0], y.surrounding)
+ self.assertEqual(8 * [0], y.surrounding)
def test_manual_request(self):
- self.assertEquals(b"\x01\x00\x00\x00", self.conn.request(0, chr(0) * 4))
+ self.assertEqual(b"\x01\x00\x00\x00", self.conn.request(0, chr(0) * 4))
def test_server_name(self):
- self.assertEquals(None, self.conn.server_name)
+ self.assertEqual(None, self.conn.server_name)
class NdrEchoTests(TestCase):
def test_info1_push(self):
x = echo.info1()
x.v = 42
- self.assertEquals(b"\x2a", ndr_pack(x))
+ self.assertEqual(b"\x2a", ndr_pack(x))
def test_info1_pull(self):
x = ndr_unpack(echo.info1, b"\x42")
- self.assertEquals(x.v, 66)
+ self.assertEqual(x.v, 66)
(ts, rs, actual) = self.conn.QueryDisplayInfo(
self.domain_handle, level, 0, 1024, 4294967295)
- self.assertEquals(len(expected), ts)
- self.assertEquals(len(expected), rs)
+ self.assertEqual(len(expected), ts)
+ self.assertEqual(len(expected), rs)
check_results(expected, actual.entries)
#
# results returned from the first query, should return the same results
(ts1, rs1, actual1) = self.conn.QueryDisplayInfo(
self.domain_handle, level, 0, rs, 4294967295)
- self.assertEquals(ts, ts1)
- self.assertEquals(rs, rs1)
+ self.assertEqual(ts, ts1)
+ self.assertEqual(rs, rs1)
check_results(expected, actual1.entries)
#
self.assertTrue(ts > 2)
(ts2, rs2, actual2) = self.conn.QueryDisplayInfo(
self.domain_handle, level, (ts - 2), 2, 4294967295)
- self.assertEquals(ts, ts2)
- self.assertEquals(2, rs2)
+ self.assertEqual(ts, ts2)
+ self.assertEqual(2, rs2)
check_results(list(expected)[-2:], actual2.entries)
#
self.assertTrue(ts > 2)
(ts2, rs2, actual2) = self.conn.QueryDisplayInfo(
self.domain_handle, level, 0, 2, 4294967295)
- self.assertEquals(ts, ts2)
- self.assertEquals(2, rs2)
+ self.assertEqual(ts, ts2)
+ self.assertEqual(2, rs2)
check_results(list(expected)[:2], actual2.entries)
#
self.assertTrue(ts > 3)
(ts2, rs2, actual2) = self.conn.QueryDisplayInfo(
self.domain_handle, level, 1, 2, 4294967295)
- self.assertEquals(ts, ts2)
- self.assertEquals(2, rs2)
+ self.assertEqual(ts, ts2)
+ self.assertEqual(2, rs2)
check_results(list(expected)[1:2], actual2.entries)
#
# should not be present
(ts3, rs3, actual3) = self.conn.QueryDisplayInfo(
self.domain_handle, level, 1, 1024, 4294967295)
- self.assertEquals(ts, ts3)
- self.assertEquals(len(expected) - 1, rs3)
+ self.assertEqual(ts, ts3)
+ self.assertEqual(len(expected) - 1, rs3)
check_results(list(expected)[1:], actual3.entries)
#
new = self.samdb.search(expression=select, attrs=attributes)
(ts4, rs4, actual4) = self.conn.QueryDisplayInfo(
self.domain_handle, level, 0, 1024, 4294967295)
- self.assertEquals(len(expected) + len(dns), ts4)
- self.assertEquals(len(expected) + len(dns), rs4)
+ self.assertEqual(len(expected) + len(dns), ts4)
+ self.assertEqual(len(expected) + len(dns), rs4)
check_results(new, actual4.entries)
# Delete the added DN's and query all but the first entry.
self.delete_dns(dns)
(ts5, rs5, actual5) = self.conn.QueryDisplayInfo(
self.domain_handle, level, 1, 1024, 4294967295)
- self.assertEquals(len(expected) + len(dns), ts5)
+ self.assertEqual(len(expected) + len(dns), ts5)
# The deleted results will be filtered from the result set so should
# be missing from the returned results.
# Note: depending on the GUID order, the first result in the cache may
# Should return no data.
(ts6, rs6, actual6) = self.conn.QueryDisplayInfo(
self.domain_handle, level, ts5, 1, 4294967295)
- self.assertEquals(ts5, ts6)
- self.assertEquals(0, rs6)
+ self.assertEqual(ts5, ts6)
+ self.assertEqual(0, rs6)
self.conn.Close(self.handle)
# in the same order
for (e, a) in zip(expected, actual):
self.assertTrue(isinstance(a, samr.DispEntryGeneral))
- self.assertEquals(str(e["sAMAccountName"]),
+ self.assertEqual(str(e["sAMAccountName"]),
str(a.account_name))
# The displayName and description are optional.
if a.full_name.length == 0:
self.assertFalse("displayName" in e)
else:
- self.assertEquals(str(e["displayName"]), str(a.full_name))
+ self.assertEqual(str(e["displayName"]), str(a.full_name))
if a.description.length == 0:
self.assertFalse("description" in e)
else:
- self.assertEquals(str(e["description"]),
+ self.assertEqual(str(e["description"]),
str(a.description))
# Create four user accounts
# to ensure that we have the minimum needed for the tests.
# in the same order
for (e, a) in zip(expected, actual):
self.assertTrue(isinstance(a, samr.DispEntryFull))
- self.assertEquals(str(e["sAMAccountName"]),
+ self.assertEqual(str(e["sAMAccountName"]),
str(a.account_name))
# The description is optional.
if a.description.length == 0:
self.assertFalse("description" in e)
else:
- self.assertEquals(str(e["description"]),
+ self.assertEqual(str(e["description"]),
str(a.description))
# Create four computer accounts
# in the same order
for (e, a) in zip(expected, actual):
self.assertTrue(isinstance(a, samr.DispEntryFullGroup))
- self.assertEquals(str(e["sAMAccountName"]),
+ self.assertEqual(str(e["sAMAccountName"]),
str(a.account_name))
# The description is optional.
if a.description.length == 0:
self.assertFalse("description" in e)
else:
- self.assertEquals(str(e["description"]),
+ self.assertEqual(str(e["description"]),
str(a.description))
# Create four groups
self.assertTrue(isinstance(a, samr.DispEntryAscii))
self.assertTrue(
isinstance(a.account_name, lsa.AsciiStringLarge))
- self.assertEquals(
+ self.assertEqual(
str(e["sAMAccountName"]), str(a.account_name.string))
# Create four user accounts
self.assertTrue(isinstance(a, samr.DispEntryAscii))
self.assertTrue(
isinstance(a.account_name, lsa.AsciiStringLarge))
- self.assertEquals(
+ self.assertEqual(
str(e["sAMAccountName"]), str(a.account_name.string))
# Create four groups
def check_results(expected, actual):
for (e, a) in zip(expected, actual):
self.assertTrue(isinstance(a, samr.SamEntry))
- self.assertEquals(
+ self.assertEqual(
str(e["sAMAccountName"]), str(a.name.string))
# Create four groups
max_size = calc_max_size(len(expected) + 10)
(resume_handle, actual, num_entries) = self.conn.EnumDomainGroups(
self.domain_handle, 0, max_size)
- self.assertEquals(len(expected), num_entries)
+ self.assertEqual(len(expected), num_entries)
check_results(expected, actual.entries)
#
max_size = calc_max_size(4)
(resume_handle, actual, num_entries) = self.conn.EnumDomainGroups(
self.domain_handle, 0, max_size)
- self.assertEquals(4, num_entries)
+ self.assertEqual(4, num_entries)
check_results(expected[:4], actual.entries)
#
(resume_handle, a, num_entries) = self.conn.EnumDomainGroups(
self.domain_handle, rh, max_size)
- self.assertEquals(0, num_entries)
- self.assertEquals(0, resume_handle)
+ self.assertEqual(0, num_entries)
+ self.assertEqual(0, resume_handle)
#
# Enumerate through the domain groups one element at a time.
(resume_handle, a, num_entries) = self.conn.EnumDomainGroups(
self.domain_handle, 0, max_size)
while resume_handle:
- self.assertEquals(1, num_entries)
+ self.assertEqual(1, num_entries)
actual.append(a.entries[0])
(resume_handle, a, num_entries) = self.conn.EnumDomainGroups(
self.domain_handle, resume_handle, max_size)
self.domain_handle, 0, max_size)
extra_dns = self.create_groups([1000, 1002, 1003, 1004])
while resume_handle:
- self.assertEquals(1, num_entries)
+ self.assertEqual(1, num_entries)
actual.append(a.entries[0])
(resume_handle, a, num_entries) = self.conn.EnumDomainGroups(
self.domain_handle, resume_handle, max_size)
if num_entries:
actual.append(a.entries[0])
- self.assertEquals(len(expected), len(actual))
+ self.assertEqual(len(expected), len(actual))
check_results(expected, actual)
#
max_size = calc_max_size(len(expected) + len(extra_dns) + 10)
(resume_handle, actual, num_entries) = self.conn.EnumDomainGroups(
self.domain_handle, 0, max_size)
- self.assertEquals(len(expected) + len(extra_dns), num_entries)
+ self.assertEqual(len(expected) + len(extra_dns), num_entries)
#
# Get a new expected result set by querying the database directly
self.domain_handle, 0, max_size)
self.delete_dns(extra_dns)
while resume_handle and num_entries:
- self.assertEquals(1, num_entries)
+ self.assertEqual(1, num_entries)
actual.append(a.entries[0])
(resume_handle, a, num_entries) = self.conn.EnumDomainGroups(
self.domain_handle, resume_handle, max_size)
if num_entries:
actual.append(a.entries[0])
- self.assertEquals(len(expected), len(actual))
+ self.assertEqual(len(expected), len(actual))
check_results(expected, actual)
self.delete_dns(dns)
def check_results(expected, actual):
for (e, a) in zip(expected, actual):
self.assertTrue(isinstance(a, samr.SamEntry))
- self.assertEquals(
+ self.assertEqual(
str(e["sAMAccountName"]), str(a.name.string))
# Create four users
max_size = calc_max_size(len(expected) + 10)
(resume_handle, actual, num_entries) = self.conn.EnumDomainUsers(
self.domain_handle, 0, 0, max_size)
- self.assertEquals(len(expected), num_entries)
+ self.assertEqual(len(expected), num_entries)
check_results(expected, actual.entries)
#
max_size = calc_max_size(4)
(resume_handle, actual, num_entries) = self.conn.EnumDomainUsers(
self.domain_handle, 0, 0, max_size)
- self.assertEquals(4, num_entries)
+ self.assertEqual(4, num_entries)
check_results(expected[:4], actual.entries)
#
(resume_handle, a, num_entries) = self.conn.EnumDomainUsers(
self.domain_handle, rh, 0, max_size)
- self.assertEquals(0, num_entries)
- self.assertEquals(0, resume_handle)
+ self.assertEqual(0, num_entries)
+ self.assertEqual(0, resume_handle)
#
# Enumerate through the domain users one element at a time.
(resume_handle, a, num_entries) = self.conn.EnumDomainUsers(
self.domain_handle, 0, 0, max_size)
while resume_handle:
- self.assertEquals(1, num_entries)
+ self.assertEqual(1, num_entries)
actual.append(a.entries[0])
(resume_handle, a, num_entries) = self.conn.EnumDomainUsers(
self.domain_handle, resume_handle, 0, max_size)
if num_entries:
actual.append(a.entries[0])
- self.assertEquals(len(expected), len(actual))
+ self.assertEqual(len(expected), len(actual))
check_results(expected, actual)
#
self.domain_handle, 0, 0, max_size)
extra_dns = self.create_users([1000, 1002, 1003, 1004])
while resume_handle:
- self.assertEquals(1, num_entries)
+ self.assertEqual(1, num_entries)
actual.append(a.entries[0])
(resume_handle, a, num_entries) = self.conn.EnumDomainUsers(
self.domain_handle, resume_handle, 0, max_size)
if num_entries:
actual.append(a.entries[0])
- self.assertEquals(len(expected), len(actual))
+ self.assertEqual(len(expected), len(actual))
check_results(expected, actual)
#
max_size = calc_max_size(len(expected) + len(extra_dns) + 10)
(resume_handle, actual, num_entries) = self.conn.EnumDomainUsers(
self.domain_handle, 0, 0, max_size)
- self.assertEquals(len(expected) + len(extra_dns), num_entries)
+ self.assertEqual(len(expected) + len(extra_dns), num_entries)
#
# Get a new expected result set by querying the database directly
#
# Now check that we read the new entries.
#
- self.assertEquals(len(expected01), num_entries)
+ self.assertEqual(len(expected01), num_entries)
check_results(expected01, actual.entries)
self.delete_dns(dns + extra_dns)
self.domain_handle, 0, 0, max_size)
count = num_entries
while resume_handle:
- self.assertEquals(1, num_entries)
+ self.assertEqual(1, num_entries)
(resume_handle, a, num_entries) = self.conn.EnumDomainUsers(
self.domain_handle, resume_handle, 0, max_size)
count += num_entries
- self.assertEquals(count, info.num_users)
+ self.assertEqual(count, info.num_users)
def test_DomGeneralInformation_num_groups(self):
info = self.conn.QueryDomainInfo(
self.domain_handle, 0, max_size)
count = num_entries
while resume_handle:
- self.assertEquals(1, num_entries)
+ self.assertEqual(1, num_entries)
(resume_handle, a, num_entries) = self.conn.EnumDomainGroups(
self.domain_handle, resume_handle, max_size)
count += num_entries
- self.assertEquals(count, info.num_groups)
+ self.assertEqual(count, info.num_groups)
def test_DomGeneralInformation_num_aliases(self):
info = self.conn.QueryDomainInfo(
self.domain_handle, 0, max_size)
count = num_entries
while resume_handle:
- self.assertEquals(1, num_entries)
+ self.assertEqual(1, num_entries)
(resume_handle, a, num_entries) = self.conn.EnumDomainAliases(
self.domain_handle, resume_handle, max_size)
count += num_entries
- self.assertEquals(count, info.num_aliases)
+ self.assertEqual(count, info.num_aliases)
def test_getpwuid_int(self):
infos = self.conn.GetPWUid(range(512))
- self.assertEquals(512, len(infos))
- self.assertEquals("/bin/false", infos[0].shell)
+ self.assertEqual(512, len(infos))
+ self.assertEqual("/bin/false", infos[0].shell)
self.assertTrue(isinstance(infos[0].homedir, text_type))
def test_gidtosid(self):
self.dns_transaction_udp(p, host=server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rdata,
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rdata,
self.server_ip)
def test_one_SOA_query(self):
self.dns_transaction_udp(p, host=server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(
response.answers[0].rdata.mname.upper(),
("%s.%s" % (self.server, self.get_dns_domain())).upper())
self.dns_transaction_tcp(p, host=server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rdata,
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rdata,
self.server_ip)
def test_one_mx_query(self):
self.dns_transaction_udp(p, host=server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 0)
+ self.assertEqual(response.ancount, 0)
p = self.make_name_packet(dns.DNS_OPCODE_QUERY)
questions = []
self.dns_transaction_udp(p, host=server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_NXDOMAIN)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 0)
+ self.assertEqual(response.ancount, 0)
def test_two_queries(self):
"create a query packet containing two query records"
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, num_answers)
- self.assertEquals(response.answers[0].rdata,
+ self.assertEqual(response.ancount, num_answers)
+ self.assertEqual(response.answers[0].rdata,
self.server_ip)
if dc_ipv6 is not None:
- self.assertEquals(response.answers[1].rdata, dc_ipv6)
+ self.assertEqual(response.answers[1].rdata, dc_ipv6)
def test_qclass_none_query(self):
"create a QCLASS_NONE query"
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
# We don't get SOA records for single hosts
- self.assertEquals(response.ancount, 0)
+ self.assertEqual(response.ancount, 0)
# But we do respond with an authority section
self.assertEqual(response.nscount, 1)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_NXDOMAIN)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
# We don't get SOA records for single hosts
- self.assertEquals(response.ancount, 0)
+ self.assertEqual(response.ancount, 0)
# But we do respond with an authority section
self.assertEqual(response.nscount, 1)
self.dns_transaction_udp(p, host=server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rdata.minimum, 3600)
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rdata.minimum, 3600)
class TestDNSUpdates(DNSTest):
self.dns_transaction_udp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 2)
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_CNAME)
- self.assertEquals(response.answers[0].rdata, "%s.%s" %
+ self.assertEqual(response.ancount, 2)
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_CNAME)
+ self.assertEqual(response.answers[0].rdata, "%s.%s" %
(self.server, self.get_dns_domain()))
- self.assertEquals(response.answers[1].rr_type, dns.DNS_QTYPE_A)
- self.assertEquals(response.answers[1].rdata,
+ self.assertEqual(response.answers[1].rr_type, dns.DNS_QTYPE_A)
+ self.assertEqual(response.answers[1].rdata,
self.server_ip)
finally:
self.dns_transaction_udp(p, host=server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 3)
+ self.assertEqual(response.ancount, 3)
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_CNAME)
- self.assertEquals(response.answers[0].name, name1)
- self.assertEquals(response.answers[0].rdata, name2)
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_CNAME)
+ self.assertEqual(response.answers[0].name, name1)
+ self.assertEqual(response.answers[0].rdata, name2)
- self.assertEquals(response.answers[1].rr_type, dns.DNS_QTYPE_CNAME)
- self.assertEquals(response.answers[1].name, name2)
- self.assertEquals(response.answers[1].rdata, name0)
+ self.assertEqual(response.answers[1].rr_type, dns.DNS_QTYPE_CNAME)
+ self.assertEqual(response.answers[1].name, name2)
+ self.assertEqual(response.answers[1].rdata, name0)
- self.assertEquals(response.answers[2].rr_type, dns.DNS_QTYPE_A)
- self.assertEquals(response.answers[2].rdata,
+ self.assertEqual(response.answers[2].rr_type, dns.DNS_QTYPE_A)
+ self.assertEqual(response.answers[2].rdata,
self.server_ip)
def test_invalid_empty_cname(self):
# CNAME should return all intermediate results!
# Only the A records exists, not the TXT.
- self.assertEquals(response.ancount, 2)
+ self.assertEqual(response.ancount, 2)
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_CNAME)
- self.assertEquals(response.answers[0].name, name1)
- self.assertEquals(response.answers[0].rdata, name2)
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_CNAME)
+ self.assertEqual(response.answers[0].name, name1)
+ self.assertEqual(response.answers[0].rdata, name2)
- self.assertEquals(response.answers[1].rr_type, dns.DNS_QTYPE_CNAME)
- self.assertEquals(response.answers[1].name, name2)
- self.assertEquals(response.answers[1].rdata, name0)
+ self.assertEqual(response.answers[1].rr_type, dns.DNS_QTYPE_CNAME)
+ self.assertEqual(response.answers[1].name, name2)
+ self.assertEqual(response.answers[1].rdata, name0)
def test_cname_loop(self):
cname1 = "cnamelooptestrec." + self.get_dns_domain()
self.dns_transaction_udp(p, host=self.server_ip)
max_recursion_depth = 20
- self.assertEquals(len(response.answers), max_recursion_depth)
+ self.assertEqual(len(response.answers), max_recursion_depth)
# Make sure cname limit doesn't count other records. This is a generic
# test called in tests below
self.dns_transaction_udp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rdata,
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rdata,
self.server_ip)
def test_one_a_reply(self):
tcp_packet += send_packet
s.send(tcp_packet, 0)
recv_packet = s.recv(0xffff + 2, 0)
- self.assertEquals(0, len(recv_packet))
+ self.assertEqual(0, len(recv_packet))
except socket.timeout:
# Windows chooses not to respond to incorrectly formatted queries.
# Although this appears to be non-deterministic even for the same
expr = "(dnsProperty:1.3.6.1.4.1.7165.4.5.3:=1)"
res = samdb.search(base=self.zone_dn, scope=ldb.SCOPE_SUBTREE,
expression=expr, attrs=["*"])
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# No value for tombstone time
try:
expr = "(dnsRecord:1.3.6.1.4.1.7165.4.5.3:=)"
res = samdb.search(base=self.zone_dn, scope=ldb.SCOPE_SUBTREE,
expression=expr, attrs=["*"])
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
self.fail("Exception: ldb.ldbError not generated")
except ldb.LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
# Tombstone time = -
try:
expr = "(dnsRecord:1.3.6.1.4.1.7165.4.5.3:=-)"
res = samdb.search(base=self.zone_dn, scope=ldb.SCOPE_SUBTREE,
expression=expr, attrs=["*"])
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
self.fail("Exception: ldb.ldbError not generated")
except ldb.LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
# Tombstone time longer than 64 characters
try:
expr = expr.format("1" * 65)
res = samdb.search(base=self.zone_dn, scope=ldb.SCOPE_SUBTREE,
expression=expr, attrs=["*"])
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
self.fail("Exception: ldb.ldbError not generated")
except ldb.LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
# Non numeric Tombstone time
try:
expr = "(dnsRecord:1.3.6.1.4.1.7165.4.5.3:=expired)"
res = samdb.search(base=self.zone_dn, scope=ldb.SCOPE_SUBTREE,
expression=expr, attrs=["*"])
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
self.fail("Exception: ldb.ldbError not generated")
except ldb.LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
# Non system session
try:
expr = "(dnsRecord:1.3.6.1.4.1.7165.4.5.3:=2)"
res = db.search(base=self.zone_dn, scope=ldb.SCOPE_SUBTREE,
expression=expr, attrs=["*"])
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
self.fail("Exception: ldb.ldbError not generated")
except ldb.LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
def test_basic_scavenging(self):
lp = self.get_loadparm()
# Windows returns OK while BIND logically seems to return NXDOMAIN
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_NXDOMAIN)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 0)
+ self.assertEqual(response.ancount, 0)
self.create_zone(zone)
(response, response_packet) =\
self.dns_transaction_udp(p, host=server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_SOA)
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_SOA)
self.delete_zone(zone)
(response, response_packet) =\
self.dns_transaction_udp(p, host=server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_NXDOMAIN)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 0)
+ self.assertEqual(response.ancount, 0)
class TestRPCRoundtrip(DNSTest):
def assert_rcode_equals(self, rcode, expected):
"Helper function to check return code"
- self.assertEquals(rcode, expected, "Expected RCODE %s, got %s" %
+ self.assertEqual(rcode, expected, "Expected RCODE %s, got %s" %
(self.errstr(expected), self.errstr(rcode)))
def assert_dns_rcode_equals(self, packet, rcode):
"Helper function to check return code"
p_errcode = packet.operation & dns.DNS_RCODE
- self.assertEquals(p_errcode, rcode, "Expected RCODE %s, got %s" %
+ self.assertEqual(p_errcode, rcode, "Expected RCODE %s, got %s" %
(self.errstr(rcode), self.errstr(p_errcode)))
def assert_dns_opcode_equals(self, packet, opcode):
"Helper function to check opcode"
p_opcode = packet.operation & dns.DNS_OPCODE
- self.assertEquals(p_opcode, opcode, "Expected OPCODE %s, got %s" %
+ self.assertEqual(p_opcode, opcode, "Expected OPCODE %s, got %s" %
(opcode, p_opcode))
def make_name_packet(self, opcode, qid=None):
# unpacking and packing again should produce same bytestream
my_packet = ndr.ndr_pack(response)
- self.assertEquals(my_packet, recv_packet[2:])
+ self.assertEqual(my_packet, recv_packet[2:])
return (response, recv_packet[2:])
def make_txt_update(self, prefix, txt_array, domain=None):
(response, response_packet) =\
self.dns_transaction_udp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rdata.txt.str, txt_array)
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rdata.txt.str, txt_array)
class DNSTKeyTest(DNSTest):
def assert_dns_rcode_equals(self, packet, rcode):
"Helper function to check return code"
p_errcode = packet.operation & dns.DNS_RCODE
- self.assertEquals(p_errcode, rcode, "Expected RCODE %s, got %s" %
+ self.assertEqual(p_errcode, rcode, "Expected RCODE %s, got %s" %
(self.errcodes[rcode], self.errcodes[p_errcode]))
def assert_dns_opcode_equals(self, packet, opcode):
"Helper function to check opcode"
p_opcode = packet.operation & dns.DNS_OPCODE
- self.assertEquals(p_opcode, opcode, "Expected OPCODE %s, got %s" %
+ self.assertEqual(p_opcode, opcode, "Expected OPCODE %s, got %s" %
(opcode, p_opcode))
def make_name_packet(self, opcode, qid=None):
(response, response_p) = self.dns_transaction_udp(p, self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_NOTAUTH)
tsig_record = response.additional[0].rdata
- self.assertEquals(tsig_record.error, dns.DNS_RCODE_BADKEY)
- self.assertEquals(tsig_record.mac_size, 0)
+ self.assertEqual(tsig_record.error, dns.DNS_RCODE_BADKEY)
+ self.assertEqual(tsig_record.mac_size, 0)
rcode = self.search_record(self.newrecname)
self.assert_rcode_equals(rcode, dns.DNS_RCODE_NXDOMAIN)
(response, response_p) = self.dns_transaction_udp(p, self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_NOTAUTH)
tsig_record = response.additional[0].rdata
- self.assertEquals(tsig_record.error, dns.DNS_RCODE_BADSIG)
- self.assertEquals(tsig_record.mac_size, 0)
+ self.assertEqual(tsig_record.error, dns.DNS_RCODE_BADSIG)
+ self.assertEqual(tsig_record.mac_size, 0)
rcode = self.search_record(self.newrecname)
self.assert_rcode_equals(rcode, dns.DNS_RCODE_NXDOMAIN)
self.dns_transaction_udp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_A)
- self.assertEquals(response.answers[0].rdata, WILDCARD_IP)
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_A)
+ self.assertEqual(response.answers[0].rdata, WILDCARD_IP)
def test_one_a_query_match_wildcard_2_labels(self):
""" Query an A record, should match the wild card entry
self.dns_transaction_udp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_A)
- self.assertEquals(response.answers[0].rdata, WILDCARD_IP)
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_A)
+ self.assertEqual(response.answers[0].rdata, WILDCARD_IP)
def test_one_a_query_wildcard_entry(self):
"Query the wildcard entry"
self.dns_transaction_udp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_A)
- self.assertEquals(response.answers[0].rdata, WILDCARD_IP)
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_A)
+ self.assertEqual(response.answers[0].rdata, WILDCARD_IP)
def test_one_a_query_exact_match(self):
"""Query an entry that matches the wild card but has an exact match as
self.dns_transaction_udp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_A)
- self.assertEquals(response.answers[0].rdata, EXACT_IP)
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_A)
+ self.assertEqual(response.answers[0].rdata, EXACT_IP)
def test_one_a_query_match_wildcard_l2(self):
"Query an A record, should match the level 2 wildcard entry"
self.dns_transaction_udp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_A)
- self.assertEquals(response.answers[0].rdata, LEVEL2_WILDCARD_IP)
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_A)
+ self.assertEqual(response.answers[0].rdata, LEVEL2_WILDCARD_IP)
def test_one_a_query_match_wildcard_l2_2_labels(self):
"""Query an A record, should match the level 2 wild card entry
self.dns_transaction_udp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_A)
- self.assertEquals(response.answers[0].rdata, LEVEL2_WILDCARD_IP)
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_A)
+ self.assertEqual(response.answers[0].rdata, LEVEL2_WILDCARD_IP)
def test_one_a_query_exact_match_l2(self):
"""Query an entry that matches the wild card but has an exact match as
self.dns_transaction_udp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_A)
- self.assertEquals(response.answers[0].rdata, LEVEL2_EXACT_IP)
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_A)
+ self.assertEqual(response.answers[0].rdata, LEVEL2_EXACT_IP)
def test_one_a_query_wildcard_entry_l2(self):
"Query the level 2 wildcard entry"
self.dns_transaction_udp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_A)
- self.assertEquals(response.answers[0].rdata, LEVEL2_WILDCARD_IP)
+ self.assertEqual(response.ancount, 1)
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_A)
+ self.assertEqual(response.answers[0].rdata, LEVEL2_WILDCARD_IP)
TestProgram(module=__name__, opts=subunitopts)
def test_get_oid_from_attrid(self):
oid = self.samdb.get_oid_from_attid(591614)
- self.assertEquals(oid, "1.2.840.113556.1.4.1790")
+ self.assertEqual(oid, "1.2.840.113556.1.4.1790")
def test_error_replpropertymetadata(self):
res = self.samdb.search(scope=ldb.SCOPE_SUBTREE,
self.samdb.modify(msg, ["local_oid:1.3.6.1.4.1.7165.4.3.14:0"])
def test_ok_get_attribute_from_attid(self):
- self.assertEquals(self.samdb.get_attribute_from_attid(13), "description")
+ self.assertEqual(self.samdb.get_attribute_from_attid(13), "description")
def test_ko_get_attribute_from_attid(self):
- self.assertEquals(self.samdb.get_attribute_from_attid(11979), None)
+ self.assertEqual(self.samdb.get_attribute_from_attid(11979), None)
def test_get_attribute_replmetadata_version(self):
res = self.samdb.search(scope=ldb.SCOPE_SUBTREE,
base=self.account_dn,
attrs=["dn"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
dn = str(res[0].dn)
self.assertEqual(self.samdb.get_attribute_replmetadata_version(dn, "unicodePwd"), 2)
res = self.samdb.search(scope=ldb.SCOPE_SUBTREE,
base=self.account_dn,
attrs=["dn"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
dn = str(res[0].dn)
version = self.samdb.get_attribute_replmetadata_version(dn, "description")
self.samdb.set_attribute_replmetadata_version(dn, "description", version + 2)
# fetch rootDSE
res = self.samdb.search(base="", expression="", scope=SCOPE_BASE, attrs=["*"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.schema_dn = res[0]["schemaNamingContext"][0]
self.base_dn = res[0]["defaultNamingContext"][0]
self.forest_level = int(res[0]["forestFunctionality"][0])
attr_res = self.samdb.search(base="@ATTRIBUTES", scope=ldb.SCOPE_BASE)
self.assertIn(attr_ldap_name, attr_res[0])
- self.assertEquals(len(attr_res[0][attr_ldap_name]), 1)
- self.assertEquals(str(attr_res[0][attr_ldap_name][0]), "CASE_INSENSITIVE")
+ self.assertEqual(len(attr_res[0][attr_ldap_name]), 1)
+ self.assertEqual(str(attr_res[0][attr_ldap_name][0]), "CASE_INSENSITIVE")
# Check @INDEXLIST
attr_res = self.samdb.search(base="@ATTRIBUTES", scope=ldb.SCOPE_BASE)
self.assertIn(attr_ldap_name, attr_res[0])
- self.assertEquals(len(attr_res[0][attr_ldap_name]), 1)
- self.assertEquals(str(attr_res[0][attr_ldap_name][0]), "CASE_INSENSITIVE")
+ self.assertEqual(len(attr_res[0][attr_ldap_name]), 1)
+ self.assertEqual(str(attr_res[0][attr_ldap_name][0]), "CASE_INSENSITIVE")
# Check @INDEXLIST
attr_res = self.samdb.search(base="@ATTRIBUTES", scope=ldb.SCOPE_BASE)
self.assertIn(attr_ldap_name, attr_res[0])
- self.assertEquals(len(attr_res[0][attr_ldap_name]), 1)
- self.assertEquals(str(attr_res[0][attr_ldap_name][0]), "CASE_INSENSITIVE")
+ self.assertEqual(len(attr_res[0][attr_ldap_name]), 1)
+ self.assertEqual(str(attr_res[0][attr_ldap_name][0]), "CASE_INSENSITIVE")
self.assertIn(attr_ldap_name2, attr_res[0])
- self.assertEquals(len(attr_res[0][attr_ldap_name2]), 1)
- self.assertEquals(str(attr_res[0][attr_ldap_name2][0]), "CASE_INSENSITIVE")
+ self.assertEqual(len(attr_res[0][attr_ldap_name2]), 1)
+ self.assertEqual(str(attr_res[0][attr_ldap_name2][0]), "CASE_INSENSITIVE")
# Check @INDEXLIST
res = self.samdb.search(base="@ATTRIBUTES", scope=ldb.SCOPE_BASE,
attrs=["@TEST_EXTRA"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), "@ATTRIBUTES")
- self.assertEquals(len(res[0]), 1)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), "@ATTRIBUTES")
+ self.assertEqual(len(res[0]), 1)
self.assertTrue("@TEST_EXTRA" in res[0])
- self.assertEquals(len(res[0]["@TEST_EXTRA"]), 1)
- self.assertEquals(str(res[0]["@TEST_EXTRA"][0]), "HIDDEN")
+ self.assertEqual(len(res[0]["@TEST_EXTRA"]), 1)
+ self.assertEqual(str(res[0]["@TEST_EXTRA"][0]), "HIDDEN")
samdb2 = samba.tests.connect_samdb(self.lp.samdb_url())
res = self.samdb.search(base="@ATTRIBUTES", scope=ldb.SCOPE_BASE,
attrs=["@TEST_EXTRA"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), "@ATTRIBUTES")
- self.assertEquals(len(res[0]), 0)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), "@ATTRIBUTES")
+ self.assertEqual(len(res[0]), 0)
self.assertFalse("@TEST_EXTRA" in res[0])
def test_modify_at_indexlist(self):
res = self.samdb.search(base="@INDEXLIST", scope=ldb.SCOPE_BASE,
attrs=["@TEST_EXTRA"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), "@INDEXLIST")
- self.assertEquals(len(res[0]), 1)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), "@INDEXLIST")
+ self.assertEqual(len(res[0]), 1)
self.assertTrue("@TEST_EXTRA" in res[0])
- self.assertEquals(len(res[0]["@TEST_EXTRA"]), 1)
- self.assertEquals(str(res[0]["@TEST_EXTRA"][0]), "1")
+ self.assertEqual(len(res[0]["@TEST_EXTRA"]), 1)
+ self.assertEqual(str(res[0]["@TEST_EXTRA"][0]), "1")
samdb2 = samba.tests.connect_samdb(self.lp.samdb_url())
res = self.samdb.search(base="@INDEXLIST", scope=ldb.SCOPE_BASE,
attrs=["@TEST_EXTRA"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), "@INDEXLIST")
- self.assertEquals(len(res[0]), 0)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), "@INDEXLIST")
+ self.assertEqual(len(res[0]), 0)
self.assertFalse("@TEST_EXTRA" in res[0])
def test_modify_fail_of_at_indexlist(self):
self.fail("modify of @INDEXLIST with a failed constraint should fail")
except LdbError as err:
enum = err.args[0]
- self.assertEquals(enum, ldb.ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(enum, ldb.ERR_NO_SUCH_ATTRIBUTE)
# Now verify that the header contains the correct magic value.
encrypted = ndr_unpack(drsblobs.EncryptedSecret, blob)
magic = 0xca5caded
- self.assertEquals(magic, encrypted.header.magic)
+ self.assertEqual(magic, encrypted.header.magic)
def test_required_features(self):
"""Test that databases are provisioned with encryptedSecrets as a
class KerberosOptionTests(samba.tests.TestCase):
def test_parse_true(self):
- self.assertEquals(
+ self.assertEqual(
MUST_USE_KERBEROS, parse_kerberos_arg("yes", "--kerberos"))
- self.assertEquals(
+ self.assertEqual(
MUST_USE_KERBEROS, parse_kerberos_arg("true", "--kerberos"))
- self.assertEquals(
+ self.assertEqual(
MUST_USE_KERBEROS, parse_kerberos_arg("1", "--kerberos"))
def test_parse_false(self):
- self.assertEquals(
+ self.assertEqual(
DONT_USE_KERBEROS, parse_kerberos_arg("no", "--kerberos"))
- self.assertEquals(
+ self.assertEqual(
DONT_USE_KERBEROS, parse_kerberos_arg("false", "--kerberos"))
- self.assertEquals(
+ self.assertEqual(
DONT_USE_KERBEROS, parse_kerberos_arg("0", "--kerberos"))
def test_parse_auto(self):
- self.assertEquals(
+ self.assertEqual(
AUTO_USE_KERBEROS, parse_kerberos_arg("auto", "--kerberos"))
def test_parse_invalid(self):
file_sys_paths = [None, '%s\\%s' % (poldir, guid)]
ds_paths = [None, 'CN=%s,%s' % (guid, dspath)]
for i in range(0, len(gpos)):
- self.assertEquals(gpos[i].name, names[i],
+ self.assertEqual(gpos[i].name, names[i],
'The gpo name did not match expected name %s' % gpos[i].name)
- self.assertEquals(gpos[i].file_sys_path, file_sys_paths[i],
+ self.assertEqual(gpos[i].file_sys_path, file_sys_paths[i],
'file_sys_path did not match expected %s' % gpos[i].file_sys_path)
- self.assertEquals(gpos[i].ds_path, ds_paths[i],
+ self.assertEqual(gpos[i].ds_path, ds_paths[i],
'ds_path did not match expected %s' % gpos[i].ds_path)
def test_gpo_ads_does_not_segfault(self):
with open(os.path.join(gpo_path, 'GPT.INI'), 'w') as gpt:
gpt.write(gpt_data % 42)
- self.assertEquals(gpo.gpo_get_sysvol_gpt_version(gpo_path)[1], 42,
+ self.assertEqual(gpo.gpo_get_sysvol_gpt_version(gpo_path)[1], 42,
'gpo_get_sysvol_gpt_version() did not return the expected version')
with open(os.path.join(gpo_path, 'GPT.INI'), 'w') as gpt:
gpt.write(gpt_data % old_vers)
- self.assertEquals(gpo.gpo_get_sysvol_gpt_version(gpo_path)[1], old_vers,
+ self.assertEqual(gpo.gpo_get_sysvol_gpt_version(gpo_path)[1], old_vers,
'gpo_get_sysvol_gpt_version() did not return the expected version')
def test_check_refresh_gpo_list(self):
after = realm + '/Policies/' \
'{31B2F340-016D-11D2-945F-00C04FB984F9}/GPT.INI'
result = check_safe_path(before)
- self.assertEquals(result, after, 'check_safe_path() didn\'t'
+ self.assertEqual(result, after, 'check_safe_path() didn\'t'
' correctly convert \\ to /')
def test_gpt_ext_register(self):
gp_exts = list_gp_extensions(self.lp.configfile)
self.assertTrue(ext_guid in gp_exts.keys(),
'Failed to list gp exts')
- self.assertEquals(gp_exts[ext_guid]['DllName'], ext_path,
+ self.assertEqual(gp_exts[ext_guid]['DllName'], ext_path,
'Failed to list gp exts')
unregister_gp_extension(ext_guid)
lp, parser = parse_gpext_conf(self.lp.configfile)
self.assertTrue('test_section' in parser.sections(),
'test_section not found in gpext.conf')
- self.assertEquals(parser.get('test_section', 'test_var'), ext_guid,
+ self.assertEqual(parser.get('test_section', 'test_var'), ext_guid,
'Failed to find test variable in gpext.conf')
parser.remove_section('test_section')
atomic_write_conf(lp, parser)
self.assertTrue(ret, 'Could not create the target %s' % gpttmpl)
ret = gpupdate_force(self.lp)
- self.assertEquals(ret, 0, 'gpupdate force failed')
+ self.assertEqual(ret, 0, 'gpupdate force failed')
gp_db = store.get_gplog(self.dc_account)
applied_guids = gp_db.get_applied_guids()
- self.assertEquals(len(applied_guids), 2, 'The guids were not found')
+ self.assertEqual(len(applied_guids), 2, 'The guids were not found')
self.assertIn(guids[0], applied_guids,
'%s not in applied guids' % guids[0])
self.assertIn(guids[1], applied_guids,
unstage_file(gpttmpl)
ret = gpupdate_unapply(self.lp)
- self.assertEquals(ret, 0, 'gpupdate unapply failed')
+ self.assertEqual(ret, 0, 'gpupdate unapply failed')
def test_process_group_policy(self):
local_path = self.lp.cache_path('gpo_cache')
#
messages = self.waitForMessages(2)
print("Received %d messages" % len(messages))
- self.assertEquals(2,
+ self.assertEqual(2,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["groupChange"]
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
# Check the Add message for the new users primary group
audit = messages[1]["groupChange"]
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
- self.assertEquals(EVT_ID_USER_ADDED_TO_GLOBAL_SEC_GROUP,
+ self.assertEqual(session_id, audit["sessionId"])
+ self.assertEqual(EVT_ID_USER_ADDED_TO_GLOBAL_SEC_GROUP,
audit["eventId"])
#
# Add the user to a group
self.ldb.add_remove_group_members(GROUP_NAME_01, [USER_NAME])
messages = self.waitForMessages(1)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["groupChange"]
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
#
# Add the user to another group
messages = self.waitForMessages(1)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["groupChange"]
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
#
# Remove the user from a group
add_members_operation=False)
messages = self.waitForMessages(1)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["groupChange"]
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
#
# Re-add the user to a group
messages = self.waitForMessages(1)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["groupChange"]
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
def test_change_primary_group(self):
#
messages = self.waitForMessages(2)
print("Received %d messages" % len(messages))
- self.assertEquals(2,
+ self.assertEqual(2,
len(messages),
"Did not receive the expected number of messages")
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
# Check the Add message for the new users primary group
audit = messages[1]["groupChange"]
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
- self.assertEquals(EVT_ID_USER_ADDED_TO_GLOBAL_SEC_GROUP,
+ self.assertEqual(session_id, audit["sessionId"])
+ self.assertEqual(EVT_ID_USER_ADDED_TO_GLOBAL_SEC_GROUP,
audit["eventId"])
#
self.ldb.add_remove_group_members(GROUP_NAME_01, [USER_NAME])
messages = self.waitForMessages(1)
print("Received %d messages" % len(messages))
- self.assertEquals(1,
+ self.assertEqual(1,
len(messages),
"Did not receive the expected number of messages")
audit = messages[0]["groupChange"]
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
- self.assertEquals(EVT_ID_USER_ADDED_TO_GLOBAL_SEC_GROUP,
+ self.assertEqual(service_description, "LDAP")
+ self.assertEqual(EVT_ID_USER_ADDED_TO_GLOBAL_SEC_GROUP,
audit["eventId"])
#
#
messages = self.waitForMessages(3)
print("Received %d messages" % len(messages))
- self.assertEquals(3,
+ self.assertEqual(3,
len(messages),
"Did not receive the expected number of messages")
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
- self.assertEquals(EVT_ID_USER_REMOVED_FROM_GLOBAL_SEC_GROUP,
+ self.assertEqual(service_description, "LDAP")
+ self.assertEqual(EVT_ID_USER_REMOVED_FROM_GLOBAL_SEC_GROUP,
audit["eventId"])
audit = messages[1]["groupChange"]
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
- self.assertEquals(EVT_ID_USER_ADDED_TO_GLOBAL_SEC_GROUP,
+ self.assertEqual(service_description, "LDAP")
+ self.assertEqual(EVT_ID_USER_ADDED_TO_GLOBAL_SEC_GROUP,
audit["eventId"])
audit = messages[2]["groupChange"]
self.remoteAddress)
self.assertTrue(self.is_guid(audit["sessionId"]))
session_id = self.get_session()
- self.assertEquals(session_id, audit["sessionId"])
+ self.assertEqual(session_id, audit["sessionId"])
service_description = self.get_service_description()
- self.assertEquals(service_description, "LDAP")
+ self.assertEqual(service_description, "LDAP")
def test_len_no_global(self):
shares = self._get_shares({})
- self.assertEquals(0, len(shares))
+ self.assertEqual(0, len(shares))
def test_iter(self):
- self.assertEquals([], list(self._get_shares({})))
- self.assertEquals([], list(self._get_shares({"global": {}})))
- self.assertEquals(
+ self.assertEqual([], list(self._get_shares({})))
+ self.assertEqual([], list(self._get_shares({"global": {}})))
+ self.assertEqual(
["bla"],
list(self._get_shares({"global": {}, "bla": {}})))
def test_len(self):
shares = self._get_shares({"global": {}})
- self.assertEquals(0, len(shares))
+ self.assertEqual(0, len(shares))
def test_getitem_nonexistent(self):
shares = self._get_shares({"global": {}})
(response, response_packet) = self.dns_transaction_tcp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, len(IPs))
+ self.assertEqual(response.ancount, len(IPs))
questions = []
name = "%s._msdcs.%s" % (self.join_ctx.ntds_guid, self.join_ctx.dnsforest)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1 + len(IPs))
- self.assertEquals(response.answers[0].rr_type, dns.DNS_QTYPE_CNAME)
- self.assertEquals(response.answers[0].rdata, self.join_ctx.dnshostname)
- self.assertEquals(response.answers[1].rr_type, dns.DNS_QTYPE_A)
+ self.assertEqual(response.ancount, 1 + len(IPs))
+ self.assertEqual(response.answers[0].rr_type, dns.DNS_QTYPE_CNAME)
+ self.assertEqual(response.answers[0].rdata, self.join_ctx.dnshostname)
+ self.assertEqual(response.answers[1].rr_type, dns.DNS_QTYPE_A)
def test_join_records_can_update(self):
dc_creds = Credentials()
(response, response_packet) = self.dns_transaction_tcp(p, host=self.server_ip)
self.assert_dns_rcode_equals(response, dns.DNS_RCODE_OK)
self.assert_dns_opcode_equals(response, dns.DNS_OPCODE_QUERY)
- self.assertEquals(response.ancount, 1)
+ self.assertEqual(response.ancount, 1)
([0x03, 0x33] * 42, 42 * 6),
(list(range(7)) * 12, 12 * 9),
(list(range(4)) * 21, 21 * 4)):
- self.assertEquals(total_schedule(schedule), total)
+ self.assertEqual(total_schedule(schedule), total)
def test_convert_schedule_to_repltimes(self):
for ntdsconn_times, repltimes in (
(list(range(7)) * 24,
[0x01, 0x23, 0x45, 0x60, 0x12, 0x34, 0x56] * 12)):
schedule = ntdsconn_schedule(ntdsconn_times)
- self.assertEquals(convert_schedule_to_repltimes(schedule),
+ self.assertEqual(convert_schedule_to_repltimes(schedule),
repltimes)
def test_new_connection_schedule(self):
schedule = new_connection_schedule()
self.assertIsInstance(schedule, drsblobs.schedule)
- self.assertEquals(schedule.size, 188)
- self.assertEquals(len(schedule.dataArray[0].slots), 168)
+ self.assertEqual(schedule.size, 188)
+ self.assertEqual(len(schedule.dataArray[0].slots), 168)
# OK, this is pathetic, but the rest of it looks really hard, with the
except Exception as e:
cmd.show_command_error(e)
retval = 1
- self.assertEquals(retcode, retval)
+ self.assertEqual(retcode, retval)
return cmd.outf.getvalue(), cmd.errf.getvalue()
def iter_all_subcommands(self):
def test_no_client_ip(self):
out, err = self.run_netcmd(cmd_testparm, ["--client-name=foo"],
retcode=-1)
- self.assertEquals("", out)
- self.assertEquals(
+ self.assertEqual("", out)
+ self.assertEqual(
"ERROR: Both a DNS name and an IP address are "
"required for the host access check\n", err)
def test_description(self):
class cmd_foo(Command):
"""Mydescription"""
- self.assertEquals("Mydescription", cmd_foo().short_description)
+ self.assertEqual("Mydescription", cmd_foo().short_description)
def test_name(self):
class cmd_foo(Command):
pass
- self.assertEquals("foo", cmd_foo().name)
+ self.assertEqual("foo", cmd_foo().name)
def test_synopsis_everywhere(self):
missing = []
setntacl(lp, self.tempf, NTACL_SDDL, DOMAIN_SID, self.session_info)
facl = getntacl(lp, self.tempf, self.session_info)
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(facl.as_sddl(anysid), NTACL_SDDL)
+ self.assertEqual(facl.as_sddl(anysid), NTACL_SDDL)
os.unlink(os.path.join(self.tempdir, "eadbtest.tdb"))
def test_setntacl_getntacl_param(self):
facl = getntacl(lp, self.tempf, self.session_info, "tdb", os.path.join(
self.tempdir, "eadbtest.tdb"))
domsid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(facl.as_sddl(domsid), NTACL_SDDL)
+ self.assertEqual(facl.as_sddl(domsid), NTACL_SDDL)
os.unlink(os.path.join(self.tempdir, "eadbtest.tdb"))
def test_setntacl_invalidbackend(self):
# This works in conjunction with the TEST_UMASK in smbd_base
# to ensure that permissions are not related to the umask
# but instead the smb.conf settings
- self.assertEquals(mode & 0o777, 0o755)
+ self.assertEqual(mode & 0o777, 0o755)
self.assertTrue(os.path.isdir(dirpath))
def test_smbd_create_file(self):
# This works in conjunction with the TEST_UMASK in smbd_base
# to ensure that permissions are not related to the umask
# but instead the smb.conf settings
- self.assertEquals(mode & 0o777, 0o644)
+ self.assertEqual(mode & 0o777, 0o644)
# As well as checking that unlink works, this removes the
# fake xattrs from the dev/inode based DB
sd2 = self.ntacls_helper.getntacl(
file_path, system_session_unix(), as_sddl=True, direct_db_access=True)
- self.assertEquals(sd0, sd1)
- self.assertEquals(sd1, sd2)
+ self.assertEqual(sd0, sd1)
+ self.assertEqual(sd1, sd2)
def test_backup_online(self):
"""
lines = out.split(b"\n")
self.assertEqual(len(lines), 4)
- self.assertEquals(lines[0], b"Authenticated: Yes")
- self.assertEquals(
+ self.assertEqual(lines[0], b"Authenticated: Yes")
+ self.assertEqual(
lines[1], b"User-Session-Key: 3F373EA8E4AF954F14FAA506F8EEBDC4")
- self.assertEquals(lines[2], b".")
- self.assertEquals(lines[3], b"")
+ self.assertEqual(lines[2], b".")
+ self.assertEqual(lines[3], b"")
# Break the password with a leading A on the challenge
ntlm_cmds[0] = "LANMAN-Challenge: A123456789abcdef"
lines = out.split(b"\n")
self.assertEqual(len(lines), 5)
- self.assertEquals(lines[0], b"Authenticated: No")
+ self.assertEqual(lines[0], b"Authenticated: No")
def test_ntlm_server_1_with_plaintext_winbind(self):
""" ntlm_auth ntlm-server-1 with plaintext password against winbind """
lines = out.split(b"\n")
self.assertEqual(len(lines), 3)
- self.assertEquals(lines[0], b"Authenticated: Yes")
- self.assertEquals(lines[1], b".")
- self.assertEquals(lines[2], b"")
+ self.assertEqual(lines[0], b"Authenticated: Yes")
+ self.assertEqual(lines[1], b".")
+ self.assertEqual(lines[2], b"")
# Check membership failure
lines = out.split(b"\n")
self.assertEqual(len(lines), 3)
- self.assertEquals(lines[0], b"Authenticated: No")
- self.assertEquals(lines[1], b".")
- self.assertEquals(lines[2], b"")
+ self.assertEqual(lines[0], b"Authenticated: No")
+ self.assertEqual(lines[1], b".")
+ self.assertEqual(lines[2], b"")
def test_ntlm_server_1_with_incorrect_password_winbind(self):
""" ntlm_auth ntlm-server-1 with incorrect fixed password against
lines = out.split(b"\n")
self.assertEqual(len(lines), 5)
- self.assertEquals(lines[0], b"Authenticated: No")
+ self.assertEqual(lines[0], b"Authenticated: No")
def test_diagnostics(self):
""" ntlm_auth diagnostics """
def test_length(self):
file = param.LoadParm()
- self.assertEquals(0, len(file))
+ self.assertEqual(0, len(file))
def test_set_workgroup(self):
file = param.LoadParm()
file.set("workgroup", "bla")
- self.assertEquals("BLA", file.get("workgroup"))
+ self.assertEqual("BLA", file.get("workgroup"))
def test_is_mydomain(self):
file = param.LoadParm()
def test_log_level(self):
samba_lp = param.LoadParm()
samba_lp.set("log level", "5 auth:4")
- self.assertEquals(5, samba_lp.log_level())
+ self.assertEqual(5, samba_lp.log_level())
def test_dump(self):
samba_lp = param.LoadParm()
# Just test successfull method execution (outputs to stdout)
- self.assertEquals(None, samba_lp.dump())
+ self.assertEqual(None, samba_lp.dump())
def test_dump_to_file(self):
samba_lp = param.LoadParm()
- self.assertEquals(None, samba_lp.dump(False, self.tempf))
+ self.assertEqual(None, samba_lp.dump(False, self.tempf))
content = open(self.tempf, 'r').read()
self.assertIn('[global]', content)
self.assertIn('interfaces', content)
samba_lp = param.LoadParm()
samba_lp.load_default()
# Just test successfull method execution
- self.assertEquals(None, samba_lp.dump_a_parameter('interfaces'))
+ self.assertEqual(None, samba_lp.dump_a_parameter('interfaces'))
def test_dump_a_parameter_to_file(self):
samba_lp = param.LoadParm()
samba_lp.load_default()
- self.assertEquals(None,
+ self.assertEqual(None,
samba_lp.dump_a_parameter('interfaces',
'global',
self.tempf))
error = "Digest expected[%s], actual[%s], " \
"user[%s], realm[%s], pass[%s]" % \
(expected, actual, user, realm, password)
- self.assertEquals(expected, actual, error)
+ self.assertEqual(expected, actual, error)
# Check all of the 29 expected WDigest values
#
def check_wdigests(self, digests):
- self.assertEquals(29, digests.num_hashes)
+ self.assertEqual(29, digests.num_hashes)
# Using the n-1 pattern in the array indexes to make it easier
# to check the tests against the spec and the samba-tool user tests.
def checkUserPassword(self, up, expected):
# Check we've received the correct number of hashes
- self.assertEquals(len(expected), up.num_hashes)
+ self.assertEqual(len(expected), up.num_hashes)
i = 0
for (tag, alg, rounds) in expected:
- self.assertEquals(tag, up.hashes[i].scheme)
+ self.assertEqual(tag, up.hashes[i].scheme)
data = up.hashes[i].value.decode('utf8').split("$")
# Check we got the expected crypt algorithm
- self.assertEquals(alg, data[1])
+ self.assertEqual(alg, data[1])
if rounds is None:
cmd = "$%s$%s" % (alg, data[2])
# Calculate the expected hash value
expected = crypt.crypt(USER_PASS, cmd)
- self.assertEquals(expected, up.hashes[i].value.decode('utf8'))
+ self.assertEqual(expected, up.hashes[i].value.decode('utf8'))
i += 1
# Check that the correct nt_hash was stored for userPassword
creds.set_password(password)
expected = creds.get_nt_hash()
actual = bytearray(nt_hash)
- self.assertEquals(expected, actual)
+ self.assertEqual(expected, actual)
# Check that we got all the expected supplemental credentials
# And they are in the expected order.
size = len(sc.sub.packages)
- self.assertEquals(3, size)
+ self.assertEqual(3, size)
(pos, package) = get_package(sc, "Primary:Kerberos")
- self.assertEquals(1, pos)
- self.assertEquals("Primary:Kerberos", package.name)
+ self.assertEqual(1, pos)
+ self.assertEqual("Primary:Kerberos", package.name)
(pos, package) = get_package(sc, "Packages")
- self.assertEquals(2, pos)
- self.assertEquals("Packages", package.name)
+ self.assertEqual(2, pos)
+ self.assertEqual("Packages", package.name)
(pos, package) = get_package(sc, "Primary:WDigest")
- self.assertEquals(3, pos)
- self.assertEquals("Primary:WDigest", package.name)
+ self.assertEqual(3, pos)
+ self.assertEqual("Primary:WDigest", package.name)
# Check that the WDigest values are correct.
#
# Check that we got all the expected supplemental credentials
# And they are in the expected order.
size = len(sc.sub.packages)
- self.assertEquals(4, size)
+ self.assertEqual(4, size)
(pos, package) = get_package(sc, "Primary:Kerberos")
- self.assertEquals(1, pos)
- self.assertEquals("Primary:Kerberos", package.name)
+ self.assertEqual(1, pos)
+ self.assertEqual("Primary:Kerberos", package.name)
(pos, wd_package) = get_package(sc, "Primary:WDigest")
- self.assertEquals(2, pos)
- self.assertEquals("Primary:WDigest", wd_package.name)
+ self.assertEqual(2, pos)
+ self.assertEqual("Primary:WDigest", wd_package.name)
(pos, package) = get_package(sc, "Packages")
- self.assertEquals(3, pos)
- self.assertEquals("Packages", package.name)
+ self.assertEqual(3, pos)
+ self.assertEqual("Packages", package.name)
(pos, up_package) = get_package(sc, "Primary:userPassword")
- self.assertEquals(4, pos)
- self.assertEquals("Primary:userPassword", up_package.name)
+ self.assertEqual(4, pos)
+ self.assertEqual("Primary:userPassword", up_package.name)
# Check that the WDigest values are correct.
#
# Check that we got all the expected supplemental credentials
# And they are in the expected order.
size = len(sc.sub.packages)
- self.assertEquals(4, size)
+ self.assertEqual(4, size)
(pos, package) = get_package(sc, "Primary:Kerberos")
- self.assertEquals(1, pos)
- self.assertEquals("Primary:Kerberos", package.name)
+ self.assertEqual(1, pos)
+ self.assertEqual("Primary:Kerberos", package.name)
(pos, wd_package) = get_package(sc, "Primary:WDigest")
- self.assertEquals(2, pos)
- self.assertEquals("Primary:WDigest", wd_package.name)
+ self.assertEqual(2, pos)
+ self.assertEqual("Primary:WDigest", wd_package.name)
(pos, package) = get_package(sc, "Packages")
- self.assertEquals(3, pos)
- self.assertEquals("Packages", package.name)
+ self.assertEqual(3, pos)
+ self.assertEqual("Packages", package.name)
(pos, ct_package) = get_package(sc, "Primary:CLEARTEXT")
- self.assertEquals(4, pos)
- self.assertEquals("Primary:CLEARTEXT", ct_package.name)
+ self.assertEqual(4, pos)
+ self.assertEqual("Primary:CLEARTEXT", ct_package.name)
# Check that the WDigest values are correct.
#
# Check the clear text value is correct.
ct = ndr_unpack(drsblobs.package_PrimaryCLEARTEXTBlob,
binascii.a2b_hex(ct_package.data))
- self.assertEquals(USER_PASS.encode('utf-16-le'), ct.cleartext)
+ self.assertEqual(USER_PASS.encode('utf-16-le'), ct.cleartext)
def test_userPassword_cleartext_sha512(self):
self.add_user(clear_text=True,
# Check that we got all the expected supplemental credentials
# And they are in the expected order.
size = len(sc.sub.packages)
- self.assertEquals(5, size)
+ self.assertEqual(5, size)
(pos, package) = get_package(sc, "Primary:Kerberos")
- self.assertEquals(1, pos)
- self.assertEquals("Primary:Kerberos", package.name)
+ self.assertEqual(1, pos)
+ self.assertEqual("Primary:Kerberos", package.name)
(pos, wd_package) = get_package(sc, "Primary:WDigest")
- self.assertEquals(2, pos)
- self.assertEquals("Primary:WDigest", wd_package.name)
+ self.assertEqual(2, pos)
+ self.assertEqual("Primary:WDigest", wd_package.name)
(pos, ct_package) = get_package(sc, "Primary:CLEARTEXT")
- self.assertEquals(3, pos)
- self.assertEquals("Primary:CLEARTEXT", ct_package.name)
+ self.assertEqual(3, pos)
+ self.assertEqual("Primary:CLEARTEXT", ct_package.name)
(pos, package) = get_package(sc, "Packages")
- self.assertEquals(4, pos)
- self.assertEquals("Packages", package.name)
+ self.assertEqual(4, pos)
+ self.assertEqual("Packages", package.name)
(pos, up_package) = get_package(sc, "Primary:userPassword")
- self.assertEquals(5, pos)
- self.assertEquals("Primary:userPassword", up_package.name)
+ self.assertEqual(5, pos)
+ self.assertEqual("Primary:userPassword", up_package.name)
# Check that the WDigest values are correct.
#
# Check the clear text value is correct.
ct = ndr_unpack(drsblobs.package_PrimaryCLEARTEXTBlob,
binascii.a2b_hex(ct_package.data))
- self.assertEquals(USER_PASS.encode('utf-16-le'), ct.cleartext)
+ self.assertEqual(USER_PASS.encode('utf-16-le'), ct.cleartext)
# Check that the userPassword hashes are computed correctly
#
# Check that we got all the expected supplemental credentials
# And they are in the expected order.
size = len(sc.sub.packages)
- self.assertEquals(4, size)
+ self.assertEqual(4, size)
(pos, package) = get_package(sc, "Primary:Kerberos-Newer-Keys")
- self.assertEquals(1, pos)
- self.assertEquals("Primary:Kerberos-Newer-Keys", package.name)
+ self.assertEqual(1, pos)
+ self.assertEqual("Primary:Kerberos-Newer-Keys", package.name)
(pos, package) = get_package(sc, "Primary:Kerberos")
- self.assertEquals(2, pos)
- self.assertEquals("Primary:Kerberos", package.name)
+ self.assertEqual(2, pos)
+ self.assertEqual("Primary:Kerberos", package.name)
(pos, package) = get_package(sc, "Packages")
- self.assertEquals(3, pos)
- self.assertEquals("Packages", package.name)
+ self.assertEqual(3, pos)
+ self.assertEqual("Packages", package.name)
(pos, package) = get_package(sc, "Primary:WDigest")
- self.assertEquals(4, pos)
- self.assertEquals("Primary:WDigest", package.name)
+ self.assertEqual(4, pos)
+ self.assertEqual("Primary:WDigest", package.name)
# Check that the WDigest values are correct.
#
# Check that we got all the expected supplemental credentials
# And they are in the expected order.
size = len(sc.sub.packages)
- self.assertEquals(5, size)
+ self.assertEqual(5, size)
(pos, package) = get_package(sc, "Primary:Kerberos-Newer-Keys")
- self.assertEquals(1, pos)
- self.assertEquals("Primary:Kerberos-Newer-Keys", package.name)
+ self.assertEqual(1, pos)
+ self.assertEqual("Primary:Kerberos-Newer-Keys", package.name)
(pos, package) = get_package(sc, "Primary:Kerberos")
- self.assertEquals(2, pos)
- self.assertEquals("Primary:Kerberos", package.name)
+ self.assertEqual(2, pos)
+ self.assertEqual("Primary:Kerberos", package.name)
(pos, wp_package) = get_package(sc, "Primary:WDigest")
- self.assertEquals(3, pos)
- self.assertEquals("Primary:WDigest", wp_package.name)
+ self.assertEqual(3, pos)
+ self.assertEqual("Primary:WDigest", wp_package.name)
(pos, package) = get_package(sc, "Packages")
- self.assertEquals(4, pos)
- self.assertEquals("Packages", package.name)
+ self.assertEqual(4, pos)
+ self.assertEqual("Packages", package.name)
(pos, up_package) = get_package(sc, "Primary:userPassword")
- self.assertEquals(5, pos)
- self.assertEquals("Primary:userPassword", up_package.name)
+ self.assertEqual(5, pos)
+ self.assertEqual("Primary:userPassword", up_package.name)
# Check that the WDigest values are correct.
#
# Check that we got all the expected supplemental credentials
# And they are in the expected order.
size = len(sc.sub.packages)
- self.assertEquals(5, size)
+ self.assertEqual(5, size)
(pos, package) = get_package(sc, "Primary:Kerberos-Newer-Keys")
- self.assertEquals(1, pos)
- self.assertEquals("Primary:Kerberos-Newer-Keys", package.name)
+ self.assertEqual(1, pos)
+ self.assertEqual("Primary:Kerberos-Newer-Keys", package.name)
(pos, package) = get_package(sc, "Primary:Kerberos")
- self.assertEquals(2, pos)
- self.assertEquals("Primary:Kerberos", package.name)
+ self.assertEqual(2, pos)
+ self.assertEqual("Primary:Kerberos", package.name)
(pos, wd_package) = get_package(sc, "Primary:WDigest")
- self.assertEquals(3, pos)
- self.assertEquals("Primary:WDigest", wd_package.name)
+ self.assertEqual(3, pos)
+ self.assertEqual("Primary:WDigest", wd_package.name)
(pos, package) = get_package(sc, "Packages")
- self.assertEquals(4, pos)
- self.assertEquals("Packages", package.name)
+ self.assertEqual(4, pos)
+ self.assertEqual("Packages", package.name)
(pos, ct_package) = get_package(sc, "Primary:CLEARTEXT")
- self.assertEquals(5, pos)
- self.assertEquals("Primary:CLEARTEXT", ct_package.name)
+ self.assertEqual(5, pos)
+ self.assertEqual("Primary:CLEARTEXT", ct_package.name)
# Check that the WDigest values are correct.
#
# Check the clear text value is correct.
ct = ndr_unpack(drsblobs.package_PrimaryCLEARTEXTBlob,
binascii.a2b_hex(ct_package.data))
- self.assertEquals(USER_PASS.encode('utf-16-le'), ct.cleartext)
+ self.assertEqual(USER_PASS.encode('utf-16-le'), ct.cleartext)
def test_userPassword_cleartext_sha256(self):
self.add_user(clear_text=True,
# Check that we got all the expected supplemental credentials
# And they are in the expected order.
size = len(sc.sub.packages)
- self.assertEquals(6, size)
+ self.assertEqual(6, size)
(pos, package) = get_package(sc, "Primary:Kerberos-Newer-Keys")
- self.assertEquals(1, pos)
- self.assertEquals("Primary:Kerberos-Newer-Keys", package.name)
+ self.assertEqual(1, pos)
+ self.assertEqual("Primary:Kerberos-Newer-Keys", package.name)
(pos, package) = get_package(sc, "Primary:Kerberos")
- self.assertEquals(2, pos)
- self.assertEquals("Primary:Kerberos", package.name)
+ self.assertEqual(2, pos)
+ self.assertEqual("Primary:Kerberos", package.name)
(pos, wd_package) = get_package(sc, "Primary:WDigest")
- self.assertEquals(3, pos)
- self.assertEquals("Primary:WDigest", wd_package.name)
+ self.assertEqual(3, pos)
+ self.assertEqual("Primary:WDigest", wd_package.name)
(pos, ct_package) = get_package(sc, "Primary:CLEARTEXT")
- self.assertEquals(4, pos)
- self.assertEquals("Primary:CLEARTEXT", ct_package.name)
+ self.assertEqual(4, pos)
+ self.assertEqual("Primary:CLEARTEXT", ct_package.name)
(pos, package) = get_package(sc, "Packages")
- self.assertEquals(5, pos)
- self.assertEquals("Packages", package.name)
+ self.assertEqual(5, pos)
+ self.assertEqual("Packages", package.name)
(pos, up_package) = get_package(sc, "Primary:userPassword")
- self.assertEquals(6, pos)
- self.assertEquals("Primary:userPassword", up_package.name)
+ self.assertEqual(6, pos)
+ self.assertEqual("Primary:userPassword", up_package.name)
# Check that the WDigest values are correct.
#
# Check the clear text value is correct.
ct = ndr_unpack(drsblobs.package_PrimaryCLEARTEXTBlob,
binascii.a2b_hex(ct_package.data))
- self.assertEquals(USER_PASS.encode('utf-16-le'), ct.cleartext)
+ self.assertEqual(USER_PASS.encode('utf-16-le'), ct.cleartext)
# Check that the userPassword hashes are computed correctly
#
# Check that we got all the expected supplemental credentials
# And they are in the expected order.
size = len(sc.sub.packages)
- self.assertEquals(5, size)
+ self.assertEqual(5, size)
(pos, package) = get_package(sc, "Primary:Kerberos-Newer-Keys")
- self.assertEquals(1, pos)
- self.assertEquals("Primary:Kerberos-Newer-Keys", package.name)
+ self.assertEqual(1, pos)
+ self.assertEqual("Primary:Kerberos-Newer-Keys", package.name)
(pos, package) = get_package(sc, "Primary:Kerberos")
- self.assertEquals(2, pos)
- self.assertEquals("Primary:Kerberos", package.name)
+ self.assertEqual(2, pos)
+ self.assertEqual("Primary:Kerberos", package.name)
(pos, wd_package) = get_package(sc, "Primary:WDigest")
- self.assertEquals(3, pos)
- self.assertEquals("Primary:WDigest", wd_package.name)
+ self.assertEqual(3, pos)
+ self.assertEqual("Primary:WDigest", wd_package.name)
(pos, package) = get_package(sc, "Packages")
- self.assertEquals(4, pos)
- self.assertEquals("Packages", package.name)
+ self.assertEqual(4, pos)
+ self.assertEqual("Packages", package.name)
(pos, package) = get_package(sc, "Primary:SambaGPG")
- self.assertEquals(5, pos)
- self.assertEquals("Primary:SambaGPG", package.name)
+ self.assertEqual(5, pos)
+ self.assertEqual("Primary:SambaGPG", package.name)
# Check that the WDigest values are correct.
#
# Check that we got all the expected supplemental credentials
# And they are in the expected order.
size = len(sc.sub.packages)
- self.assertEquals(6, size)
+ self.assertEqual(6, size)
(pos, package) = get_package(sc, "Primary:Kerberos-Newer-Keys")
- self.assertEquals(1, pos)
- self.assertEquals("Primary:Kerberos-Newer-Keys", package.name)
+ self.assertEqual(1, pos)
+ self.assertEqual("Primary:Kerberos-Newer-Keys", package.name)
(pos, package) = get_package(sc, "Primary:Kerberos")
- self.assertEquals(2, pos)
- self.assertEquals("Primary:Kerberos", package.name)
+ self.assertEqual(2, pos)
+ self.assertEqual("Primary:Kerberos", package.name)
(pos, wd_package) = get_package(sc, "Primary:WDigest")
- self.assertEquals(3, pos)
- self.assertEquals("Primary:WDigest", wd_package.name)
+ self.assertEqual(3, pos)
+ self.assertEqual("Primary:WDigest", wd_package.name)
(pos, ct_package) = get_package(sc, "Primary:CLEARTEXT")
- self.assertEquals(4, pos)
- self.assertEquals("Primary:CLEARTEXT", ct_package.name)
+ self.assertEqual(4, pos)
+ self.assertEqual("Primary:CLEARTEXT", ct_package.name)
(pos, package) = get_package(sc, "Packages")
- self.assertEquals(5, pos)
- self.assertEquals("Packages", package.name)
+ self.assertEqual(5, pos)
+ self.assertEqual("Packages", package.name)
(pos, package) = get_package(sc, "Primary:SambaGPG")
- self.assertEquals(6, pos)
- self.assertEquals("Primary:SambaGPG", package.name)
+ self.assertEqual(6, pos)
+ self.assertEqual("Primary:SambaGPG", package.name)
# Check that the WDigest values are correct.
#
# Check the clear text value is correct.
ct = ndr_unpack(drsblobs.package_PrimaryCLEARTEXTBlob,
binascii.a2b_hex(ct_package.data))
- self.assertEquals(USER_PASS.encode('utf-16-le'), ct.cleartext)
+ self.assertEqual(USER_PASS.encode('utf-16-le'), ct.cleartext)
def assert_cleartext(self, expect_cleartext, password=None):
"""Checks cleartext is (or isn't) returned as expected"""
# Check the clear-text value is correct.
ct = ndr_unpack(drsblobs.package_PrimaryCLEARTEXTBlob,
binascii.a2b_hex(ct_package.data))
- self.assertEquals(password.encode('utf-16-le'), ct.cleartext)
+ self.assertEqual(password.encode('utf-16-le'), ct.cleartext)
else:
ct_package = get_package(sc, "Primary:CLEARTEXT")
self.assertTrue(ct_package is None,
# Check that we got all the expected supplemental credentials
# And they are in the expected order.
size = len(sc.sub.packages)
- self.assertEquals(6, size)
+ self.assertEqual(6, size)
(pos, package) = get_package(sc, "Primary:Kerberos-Newer-Keys")
- self.assertEquals(1, pos)
- self.assertEquals("Primary:Kerberos-Newer-Keys", package.name)
+ self.assertEqual(1, pos)
+ self.assertEqual("Primary:Kerberos-Newer-Keys", package.name)
(pos, package) = get_package(sc, "Primary:Kerberos")
- self.assertEquals(2, pos)
- self.assertEquals("Primary:Kerberos", package.name)
+ self.assertEqual(2, pos)
+ self.assertEqual("Primary:Kerberos", package.name)
(pos, wp_package) = get_package(sc, "Primary:WDigest")
- self.assertEquals(3, pos)
- self.assertEquals("Primary:WDigest", wp_package.name)
+ self.assertEqual(3, pos)
+ self.assertEqual("Primary:WDigest", wp_package.name)
(pos, up_package) = get_package(sc, "Primary:userPassword")
- self.assertEquals(4, pos)
- self.assertEquals("Primary:userPassword", up_package.name)
+ self.assertEqual(4, pos)
+ self.assertEqual("Primary:userPassword", up_package.name)
(pos, package) = get_package(sc, "Packages")
- self.assertEquals(5, pos)
- self.assertEquals("Packages", package.name)
+ self.assertEqual(5, pos)
+ self.assertEqual("Packages", package.name)
(pos, package) = get_package(sc, "Primary:SambaGPG")
- self.assertEquals(6, pos)
- self.assertEquals("Primary:SambaGPG", package.name)
+ self.assertEqual(6, pos)
+ self.assertEqual("Primary:SambaGPG", package.name)
# Check that the WDigest values are correct.
#
# Check that we got all the expected supplemental credentials
# And they are in the expected order.
size = len(sc.sub.packages)
- self.assertEquals(6, size)
+ self.assertEqual(6, size)
(pos, package) = get_package(sc, "Primary:Kerberos-Newer-Keys")
- self.assertEquals(1, pos)
- self.assertEquals("Primary:Kerberos-Newer-Keys", package.name)
+ self.assertEqual(1, pos)
+ self.assertEqual("Primary:Kerberos-Newer-Keys", package.name)
(pos, package) = get_package(sc, "Primary:Kerberos")
- self.assertEquals(2, pos)
- self.assertEquals("Primary:Kerberos", package.name)
+ self.assertEqual(2, pos)
+ self.assertEqual("Primary:Kerberos", package.name)
(pos, wp_package) = get_package(sc, "Primary:WDigest")
- self.assertEquals(3, pos)
- self.assertEquals("Primary:WDigest", wp_package.name)
+ self.assertEqual(3, pos)
+ self.assertEqual("Primary:WDigest", wp_package.name)
(pos, up_package) = get_package(sc, "Primary:userPassword")
- self.assertEquals(4, pos)
- self.assertEquals("Primary:userPassword", up_package.name)
+ self.assertEqual(4, pos)
+ self.assertEqual("Primary:userPassword", up_package.name)
(pos, package) = get_package(sc, "Packages")
- self.assertEquals(5, pos)
- self.assertEquals("Packages", package.name)
+ self.assertEqual(5, pos)
+ self.assertEqual("Packages", package.name)
(pos, package) = get_package(sc, "Primary:SambaGPG")
- self.assertEquals(6, pos)
- self.assertEquals("Primary:SambaGPG", package.name)
+ self.assertEqual(6, pos)
+ self.assertEqual("Primary:SambaGPG", package.name)
# Check that the WDigest values are correct.
#
sc = self.get_supplemental_creds_drs()
(pos, package) = get_package(sc, "Primary:WDigest")
- self.assertEquals("Primary:WDigest", package.name)
+ self.assertEqual("Primary:WDigest", package.name)
# Check that the WDigest values are correct.
#
class PolicyTests(TestCase):
def test_get_gpo_flags(self):
- self.assertEquals(["GPO_FLAG_USER_DISABLE"],
+ self.assertEqual(["GPO_FLAG_USER_DISABLE"],
policy.get_gpo_flags(policy.GPO_FLAG_USER_DISABLE))
def test_get_gplink_options(self):
- self.assertEquals(["GPLINK_OPT_DISABLE"],
+ self.assertEqual(["GPLINK_OPT_DISABLE"],
policy.get_gplink_options(policy.GPLINK_OPT_DISABLE))
self.get_session_info(), use_ntvfs=True)
facl = getntacl(self.lp, self.tempf, self.get_session_info(), direct_db_access=True)
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(facl.as_sddl(anysid), acl)
+ self.assertEqual(facl.as_sddl(anysid), acl)
def test_setntacl_smbd_setposixacl_getntacl(self):
acl = ACL
# however, as this is direct DB access, we do not notice it
facl = getntacl(self.lp, self.tempf, self.get_session_info(), direct_db_access=True)
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(acl, facl.as_sddl(anysid))
+ self.assertEqual(acl, facl.as_sddl(anysid))
def test_setntacl_invalidate_getntacl_smbd(self):
acl = ACL
# the hash would break, and we return an ACL based only on the mode, except we set the ACL using the 'ntvfs' mode that doesn't include a hash
facl = getntacl(self.lp, self.tempf, self.get_session_info())
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(acl, facl.as_sddl(anysid))
+ self.assertEqual(acl, facl.as_sddl(anysid))
def test_setntacl_smbd_invalidate_getntacl_smbd(self):
acl = ACL
# the hash will break, and we return an ACL based only on the mode
facl = getntacl(self.lp, self.tempf, self.get_session_info(), direct_db_access=False)
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(simple_acl_from_posix, facl.as_sddl(anysid))
+ self.assertEqual(simple_acl_from_posix, facl.as_sddl(anysid))
def test_setntacl_getntacl_smbd(self):
acl = ACL
self.get_session_info(), use_ntvfs=True)
facl = getntacl(self.lp, self.tempf, self.get_session_info(), direct_db_access=False)
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(facl.as_sddl(anysid), acl)
+ self.assertEqual(facl.as_sddl(anysid), acl)
def test_setntacl_smbd_getntacl_smbd(self):
acl = ACL
self.get_session_info(), use_ntvfs=False)
facl = getntacl(self.lp, self.tempf, self.get_session_info(), direct_db_access=False)
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(facl.as_sddl(anysid), acl)
+ self.assertEqual(facl.as_sddl(anysid), acl)
def test_setntacl_smbd_setposixacl_getntacl_smbd(self):
acl = ACL
smbd.set_simple_acl(self.tempf, 0o640, self.get_session_info())
facl = getntacl(self.lp, self.tempf, self.get_session_info(), direct_db_access=False)
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(simple_acl_from_posix, facl.as_sddl(anysid))
+ self.assertEqual(simple_acl_from_posix, facl.as_sddl(anysid))
def test_setntacl_smbd_setposixacl_group_getntacl_smbd(self):
acl = ACL
# This should re-calculate an ACL based on the posix details
facl = getntacl(self.lp, self.tempf, self.get_session_info(), direct_db_access=False)
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(simple_acl_from_posix, facl.as_sddl(anysid))
+ self.assertEqual(simple_acl_from_posix, facl.as_sddl(anysid))
def test_setntacl_smbd_getntacl_smbd_gpo(self):
acl = "O:DAG:DUD:P(A;OICI;0x001f01ff;;;DA)(A;OICI;0x001f01ff;;;EA)(A;OICIIO;0x001f01ff;;;CO)(A;OICI;0x001f01ff;;;DA)(A;OICI;0x001f01ff;;;SY)(A;OICI;0x001200a9;;;AU)(A;OICI;0x001200a9;;;ED)S:AI(OU;CIIDSA;WP;f30e3bbe-9ff0-11d1-b603-0000f80367c1;bf967aa5-0de6-11d0-a285-00aa003049e2;WD)(OU;CIIDSA;WP;f30e3bbf-9ff0-11d1-b603-0000f80367c1;bf967aa5-0de6-11d0-a285-00aa003049e2;WD)"
self.get_session_info(), use_ntvfs=False)
facl = getntacl(self.lp, self.tempf, self.get_session_info(), direct_db_access=False)
domsid = security.dom_sid(DOM_SID)
- self.assertEquals(facl.as_sddl(domsid), acl)
+ self.assertEqual(facl.as_sddl(domsid), acl)
def test_setntacl_getposixacl(self):
acl = ACL
self.get_session_info(), use_ntvfs=False)
facl = getntacl(self.lp, self.tempf, self.get_session_info())
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(facl.as_sddl(anysid), acl)
+ self.assertEqual(facl.as_sddl(anysid), acl)
posix_acl = smbd.get_sys_acl(self.tempf, smb_acl.SMB_ACL_TYPE_ACCESS, self.get_session_info())
def test_setposixacl_getntacl(self):
facl = getntacl(self.lp, self.tempf, self.get_session_info(), direct_db_access=False)
acl = "O:%sG:%sD:(A;;0x001f019f;;;%s)(A;;0x00120089;;;%s)(A;;;;;WD)" % (user_SID, group_SID, user_SID, group_SID)
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(acl, facl.as_sddl(anysid))
+ self.assertEqual(acl, facl.as_sddl(anysid))
def test_setposixacl_dir_getntacl_smbd(self):
s4_passdb = passdb.PDB(self.lp.get("passdb backend"))
BA_sid = security.dom_sid(security.SID_BUILTIN_ADMINISTRATORS)
s4_passdb = passdb.PDB(self.lp.get("passdb backend"))
(BA_id, BA_type) = s4_passdb.sid_to_id(BA_sid)
- self.assertEquals(BA_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(BA_type, idmap.ID_TYPE_BOTH)
SO_sid = security.dom_sid(security.SID_BUILTIN_SERVER_OPERATORS)
(SO_id, SO_type) = s4_passdb.sid_to_id(SO_sid)
- self.assertEquals(SO_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(SO_type, idmap.ID_TYPE_BOTH)
smbd.chown(self.tempdir, BA_id, SO_id, self.get_session_info())
smbd.set_simple_acl(self.tempdir, 0o750, self.get_session_info())
facl = getntacl(self.lp, self.tempdir, self.get_session_info(), direct_db_access=False)
acl = "O:BAG:SOD:(A;;0x001f01ff;;;BA)(A;;0x001200a9;;;SO)(A;;;;;WD)(A;OICIIO;0x001f01ff;;;CO)(A;OICIIO;0x001200a9;;;CG)(A;OICIIO;0x001200a9;;;WD)"
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(acl, facl.as_sddl(anysid))
+ self.assertEqual(acl, facl.as_sddl(anysid))
def test_setposixacl_group_getntacl_smbd(self):
BA_sid = security.dom_sid(security.SID_BUILTIN_ADMINISTRATORS)
(BA_gid, BA_type) = s4_passdb.sid_to_id(BA_sid)
group_SID = s4_passdb.gid_to_sid(os.stat(self.tempf).st_gid)
user_SID = s4_passdb.uid_to_sid(os.stat(self.tempf).st_uid)
- self.assertEquals(BA_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(BA_type, idmap.ID_TYPE_BOTH)
smbd.set_simple_acl(self.tempf, 0o640, self.get_session_info(), BA_gid)
facl = getntacl(self.lp, self.tempf, self.get_session_info(), direct_db_access=False)
domsid = passdb.get_global_sam_sid()
acl = "O:%sG:%sD:(A;;0x001f019f;;;%s)(A;;0x00120089;;;BA)(A;;0x00120089;;;%s)(A;;;;;WD)" % (user_SID, group_SID, user_SID, group_SID)
anysid = security.dom_sid(security.SID_NT_SELF)
- self.assertEquals(acl, facl.as_sddl(anysid))
+ self.assertEqual(acl, facl.as_sddl(anysid))
def test_setposixacl_getposixacl(self):
smbd.set_simple_acl(self.tempf, 0o640, self.get_session_info())
posix_acl = smbd.get_sys_acl(self.tempf, smb_acl.SMB_ACL_TYPE_ACCESS, self.get_session_info())
- self.assertEquals(posix_acl.count, 4, self.print_posix_acl(posix_acl))
+ self.assertEqual(posix_acl.count, 4, self.print_posix_acl(posix_acl))
- self.assertEquals(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_USER_OBJ)
- self.assertEquals(posix_acl.acl[0].a_perm, 6)
+ self.assertEqual(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_USER_OBJ)
+ self.assertEqual(posix_acl.acl[0].a_perm, 6)
- self.assertEquals(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
- self.assertEquals(posix_acl.acl[1].a_perm, 4)
+ self.assertEqual(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
+ self.assertEqual(posix_acl.acl[1].a_perm, 4)
- self.assertEquals(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
- self.assertEquals(posix_acl.acl[2].a_perm, 0)
+ self.assertEqual(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
+ self.assertEqual(posix_acl.acl[2].a_perm, 0)
- self.assertEquals(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_MASK)
- self.assertEquals(posix_acl.acl[3].a_perm, 7)
+ self.assertEqual(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_MASK)
+ self.assertEqual(posix_acl.acl[3].a_perm, 7)
def test_setposixacl_dir_getposixacl(self):
smbd.set_simple_acl(self.tempdir, 0o750, self.get_session_info())
posix_acl = smbd.get_sys_acl(self.tempdir, smb_acl.SMB_ACL_TYPE_ACCESS, self.get_session_info())
- self.assertEquals(posix_acl.count, 4, self.print_posix_acl(posix_acl))
+ self.assertEqual(posix_acl.count, 4, self.print_posix_acl(posix_acl))
- self.assertEquals(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_USER_OBJ)
- self.assertEquals(posix_acl.acl[0].a_perm, 7)
+ self.assertEqual(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_USER_OBJ)
+ self.assertEqual(posix_acl.acl[0].a_perm, 7)
- self.assertEquals(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
- self.assertEquals(posix_acl.acl[1].a_perm, 5)
+ self.assertEqual(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
+ self.assertEqual(posix_acl.acl[1].a_perm, 5)
- self.assertEquals(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
- self.assertEquals(posix_acl.acl[2].a_perm, 0)
+ self.assertEqual(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
+ self.assertEqual(posix_acl.acl[2].a_perm, 0)
- self.assertEquals(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_MASK)
- self.assertEquals(posix_acl.acl[3].a_perm, 7)
+ self.assertEqual(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_MASK)
+ self.assertEqual(posix_acl.acl[3].a_perm, 7)
def test_setposixacl_group_getposixacl(self):
BA_sid = security.dom_sid(security.SID_BUILTIN_ADMINISTRATORS)
s4_passdb = passdb.PDB(self.lp.get("passdb backend"))
(BA_gid, BA_type) = s4_passdb.sid_to_id(BA_sid)
- self.assertEquals(BA_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(BA_type, idmap.ID_TYPE_BOTH)
smbd.set_simple_acl(self.tempf, 0o670, self.get_session_info(), BA_gid)
posix_acl = smbd.get_sys_acl(self.tempf, smb_acl.SMB_ACL_TYPE_ACCESS, self.get_session_info())
- self.assertEquals(posix_acl.count, 5, self.print_posix_acl(posix_acl))
+ self.assertEqual(posix_acl.count, 5, self.print_posix_acl(posix_acl))
- self.assertEquals(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_USER_OBJ)
- self.assertEquals(posix_acl.acl[0].a_perm, 6)
+ self.assertEqual(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_USER_OBJ)
+ self.assertEqual(posix_acl.acl[0].a_perm, 6)
- self.assertEquals(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
- self.assertEquals(posix_acl.acl[1].a_perm, 7)
+ self.assertEqual(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
+ self.assertEqual(posix_acl.acl[1].a_perm, 7)
- self.assertEquals(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
- self.assertEquals(posix_acl.acl[2].a_perm, 0)
+ self.assertEqual(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
+ self.assertEqual(posix_acl.acl[2].a_perm, 0)
- self.assertEquals(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[3].a_perm, 7)
- self.assertEquals(posix_acl.acl[3].info.gid, BA_gid)
+ self.assertEqual(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[3].a_perm, 7)
+ self.assertEqual(posix_acl.acl[3].info.gid, BA_gid)
- self.assertEquals(posix_acl.acl[4].a_type, smb_acl.SMB_ACL_MASK)
- self.assertEquals(posix_acl.acl[4].a_perm, 7)
+ self.assertEqual(posix_acl.acl[4].a_type, smb_acl.SMB_ACL_MASK)
+ self.assertEqual(posix_acl.acl[4].a_perm, 7)
def test_setntacl_sysvol_check_getposixacl(self):
acl = provision.SYSVOL_ACL
setntacl(self.lp, self.tempf, acl, str(domsid),
session_info, use_ntvfs=False)
facl = getntacl(self.lp, self.tempf, session_info)
- self.assertEquals(facl.as_sddl(domsid), acl)
+ self.assertEqual(facl.as_sddl(domsid), acl)
posix_acl = smbd.get_sys_acl(self.tempf, smb_acl.SMB_ACL_TYPE_ACCESS, session_info)
nwrap_module_so_path = os.getenv('NSS_WRAPPER_MODULE_SO_PATH')
# configuration. When other environments have a broad range of
# groups mapped via passdb, we can relax some of these checks
(LA_uid, LA_type) = s4_passdb.sid_to_id(LA_sid)
- self.assertEquals(LA_type, idmap.ID_TYPE_UID)
+ self.assertEqual(LA_type, idmap.ID_TYPE_UID)
(BA_gid, BA_type) = s4_passdb.sid_to_id(BA_sid)
- self.assertEquals(BA_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(BA_type, idmap.ID_TYPE_BOTH)
(SO_gid, SO_type) = s4_passdb.sid_to_id(SO_sid)
- self.assertEquals(SO_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(SO_type, idmap.ID_TYPE_BOTH)
(SY_gid, SY_type) = s4_passdb.sid_to_id(SY_sid)
- self.assertEquals(SO_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(SO_type, idmap.ID_TYPE_BOTH)
(AU_gid, AU_type) = s4_passdb.sid_to_id(AU_sid)
- self.assertEquals(AU_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(AU_type, idmap.ID_TYPE_BOTH)
- self.assertEquals(posix_acl.count, 13, self.print_posix_acl(posix_acl))
+ self.assertEqual(posix_acl.count, 13, self.print_posix_acl(posix_acl))
- self.assertEquals(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[0].a_perm, 7)
- self.assertEquals(posix_acl.acl[0].info.gid, BA_gid)
+ self.assertEqual(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[0].a_perm, 7)
+ self.assertEqual(posix_acl.acl[0].info.gid, BA_gid)
- self.assertEquals(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_USER)
if nwrap_winbind_active or is_user_session:
- self.assertEquals(posix_acl.acl[1].a_perm, 7)
+ self.assertEqual(posix_acl.acl[1].a_perm, 7)
else:
- self.assertEquals(posix_acl.acl[1].a_perm, 6)
- self.assertEquals(posix_acl.acl[1].info.uid, LA_uid)
+ self.assertEqual(posix_acl.acl[1].a_perm, 6)
+ self.assertEqual(posix_acl.acl[1].info.uid, LA_uid)
- self.assertEquals(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
- self.assertEquals(posix_acl.acl[2].a_perm, 0)
+ self.assertEqual(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
+ self.assertEqual(posix_acl.acl[2].a_perm, 0)
- self.assertEquals(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_USER_OBJ)
+ self.assertEqual(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_USER_OBJ)
if nwrap_winbind_active or is_user_session:
- self.assertEquals(posix_acl.acl[3].a_perm, 7)
+ self.assertEqual(posix_acl.acl[3].a_perm, 7)
else:
- self.assertEquals(posix_acl.acl[3].a_perm, 6)
+ self.assertEqual(posix_acl.acl[3].a_perm, 6)
- self.assertEquals(posix_acl.acl[4].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[4].a_perm, 7)
- self.assertEquals(posix_acl.acl[4].info.uid, BA_gid)
+ self.assertEqual(posix_acl.acl[4].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[4].a_perm, 7)
+ self.assertEqual(posix_acl.acl[4].info.uid, BA_gid)
- self.assertEquals(posix_acl.acl[5].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
- self.assertEquals(posix_acl.acl[5].a_perm, 7)
+ self.assertEqual(posix_acl.acl[5].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
+ self.assertEqual(posix_acl.acl[5].a_perm, 7)
- self.assertEquals(posix_acl.acl[6].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[6].a_perm, 5)
- self.assertEquals(posix_acl.acl[6].info.uid, SO_gid)
+ self.assertEqual(posix_acl.acl[6].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[6].a_perm, 5)
+ self.assertEqual(posix_acl.acl[6].info.uid, SO_gid)
- self.assertEquals(posix_acl.acl[7].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[7].a_perm, 5)
- self.assertEquals(posix_acl.acl[7].info.gid, SO_gid)
+ self.assertEqual(posix_acl.acl[7].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[7].a_perm, 5)
+ self.assertEqual(posix_acl.acl[7].info.gid, SO_gid)
- self.assertEquals(posix_acl.acl[8].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[8].a_perm, 7)
- self.assertEquals(posix_acl.acl[8].info.uid, SY_gid)
+ self.assertEqual(posix_acl.acl[8].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[8].a_perm, 7)
+ self.assertEqual(posix_acl.acl[8].info.uid, SY_gid)
- self.assertEquals(posix_acl.acl[9].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[9].a_perm, 7)
- self.assertEquals(posix_acl.acl[9].info.gid, SY_gid)
+ self.assertEqual(posix_acl.acl[9].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[9].a_perm, 7)
+ self.assertEqual(posix_acl.acl[9].info.gid, SY_gid)
- self.assertEquals(posix_acl.acl[10].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[10].a_perm, 5)
- self.assertEquals(posix_acl.acl[10].info.uid, AU_gid)
+ self.assertEqual(posix_acl.acl[10].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[10].a_perm, 5)
+ self.assertEqual(posix_acl.acl[10].info.uid, AU_gid)
- self.assertEquals(posix_acl.acl[11].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[11].a_perm, 5)
- self.assertEquals(posix_acl.acl[11].info.gid, AU_gid)
+ self.assertEqual(posix_acl.acl[11].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[11].a_perm, 5)
+ self.assertEqual(posix_acl.acl[11].info.gid, AU_gid)
- self.assertEquals(posix_acl.acl[12].a_type, smb_acl.SMB_ACL_MASK)
- self.assertEquals(posix_acl.acl[12].a_perm, 7)
+ self.assertEqual(posix_acl.acl[12].a_type, smb_acl.SMB_ACL_MASK)
+ self.assertEqual(posix_acl.acl[12].a_perm, 7)
# check that it matches:
# user::rwx
setntacl(self.lp, self.tempdir, acl, str(domsid),
session_info, use_ntvfs=False)
facl = getntacl(self.lp, self.tempdir, session_info)
- self.assertEquals(facl.as_sddl(domsid), acl)
+ self.assertEqual(facl.as_sddl(domsid), acl)
posix_acl = smbd.get_sys_acl(self.tempdir, smb_acl.SMB_ACL_TYPE_ACCESS, session_info)
LA_sid = security.dom_sid(str(domsid) + "-" + str(security.DOMAIN_RID_ADMINISTRATOR))
# configuration. When other environments have a broad range of
# groups mapped via passdb, we can relax some of these checks
(LA_uid, LA_type) = s4_passdb.sid_to_id(LA_sid)
- self.assertEquals(LA_type, idmap.ID_TYPE_UID)
+ self.assertEqual(LA_type, idmap.ID_TYPE_UID)
(BA_gid, BA_type) = s4_passdb.sid_to_id(BA_sid)
- self.assertEquals(BA_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(BA_type, idmap.ID_TYPE_BOTH)
(SO_gid, SO_type) = s4_passdb.sid_to_id(SO_sid)
- self.assertEquals(SO_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(SO_type, idmap.ID_TYPE_BOTH)
(SY_gid, SY_type) = s4_passdb.sid_to_id(SY_sid)
- self.assertEquals(SO_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(SO_type, idmap.ID_TYPE_BOTH)
(AU_gid, AU_type) = s4_passdb.sid_to_id(AU_sid)
- self.assertEquals(AU_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(AU_type, idmap.ID_TYPE_BOTH)
- self.assertEquals(posix_acl.count, 13, self.print_posix_acl(posix_acl))
+ self.assertEqual(posix_acl.count, 13, self.print_posix_acl(posix_acl))
- self.assertEquals(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[0].a_perm, 7)
- self.assertEquals(posix_acl.acl[0].info.gid, BA_gid)
+ self.assertEqual(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[0].a_perm, 7)
+ self.assertEqual(posix_acl.acl[0].info.gid, BA_gid)
- self.assertEquals(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[1].a_perm, 7)
- self.assertEquals(posix_acl.acl[1].info.uid, LA_uid)
+ self.assertEqual(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[1].a_perm, 7)
+ self.assertEqual(posix_acl.acl[1].info.uid, LA_uid)
- self.assertEquals(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
- self.assertEquals(posix_acl.acl[2].a_perm, 0)
+ self.assertEqual(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
+ self.assertEqual(posix_acl.acl[2].a_perm, 0)
- self.assertEquals(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_USER_OBJ)
- self.assertEquals(posix_acl.acl[3].a_perm, 7)
+ self.assertEqual(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_USER_OBJ)
+ self.assertEqual(posix_acl.acl[3].a_perm, 7)
- self.assertEquals(posix_acl.acl[4].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[4].a_perm, 7)
- self.assertEquals(posix_acl.acl[4].info.uid, BA_gid)
+ self.assertEqual(posix_acl.acl[4].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[4].a_perm, 7)
+ self.assertEqual(posix_acl.acl[4].info.uid, BA_gid)
- self.assertEquals(posix_acl.acl[5].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
- self.assertEquals(posix_acl.acl[5].a_perm, 7)
+ self.assertEqual(posix_acl.acl[5].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
+ self.assertEqual(posix_acl.acl[5].a_perm, 7)
- self.assertEquals(posix_acl.acl[6].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[6].a_perm, 5)
- self.assertEquals(posix_acl.acl[6].info.uid, SO_gid)
+ self.assertEqual(posix_acl.acl[6].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[6].a_perm, 5)
+ self.assertEqual(posix_acl.acl[6].info.uid, SO_gid)
- self.assertEquals(posix_acl.acl[7].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[7].a_perm, 5)
- self.assertEquals(posix_acl.acl[7].info.gid, SO_gid)
+ self.assertEqual(posix_acl.acl[7].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[7].a_perm, 5)
+ self.assertEqual(posix_acl.acl[7].info.gid, SO_gid)
- self.assertEquals(posix_acl.acl[8].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[8].a_perm, 7)
- self.assertEquals(posix_acl.acl[8].info.uid, SY_gid)
+ self.assertEqual(posix_acl.acl[8].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[8].a_perm, 7)
+ self.assertEqual(posix_acl.acl[8].info.uid, SY_gid)
- self.assertEquals(posix_acl.acl[9].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[9].a_perm, 7)
- self.assertEquals(posix_acl.acl[9].info.gid, SY_gid)
+ self.assertEqual(posix_acl.acl[9].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[9].a_perm, 7)
+ self.assertEqual(posix_acl.acl[9].info.gid, SY_gid)
- self.assertEquals(posix_acl.acl[10].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[10].a_perm, 5)
- self.assertEquals(posix_acl.acl[10].info.uid, AU_gid)
+ self.assertEqual(posix_acl.acl[10].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[10].a_perm, 5)
+ self.assertEqual(posix_acl.acl[10].info.uid, AU_gid)
- self.assertEquals(posix_acl.acl[11].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[11].a_perm, 5)
- self.assertEquals(posix_acl.acl[11].info.gid, AU_gid)
+ self.assertEqual(posix_acl.acl[11].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[11].a_perm, 5)
+ self.assertEqual(posix_acl.acl[11].info.gid, AU_gid)
- self.assertEquals(posix_acl.acl[12].a_type, smb_acl.SMB_ACL_MASK)
- self.assertEquals(posix_acl.acl[12].a_perm, 7)
+ self.assertEqual(posix_acl.acl[12].a_type, smb_acl.SMB_ACL_MASK)
+ self.assertEqual(posix_acl.acl[12].a_perm, 7)
# check that it matches:
# user::rwx
setntacl(self.lp, self.tempdir, acl, str(domsid),
session_info, use_ntvfs=False)
facl = getntacl(self.lp, self.tempdir, session_info)
- self.assertEquals(facl.as_sddl(domsid), acl)
+ self.assertEqual(facl.as_sddl(domsid), acl)
posix_acl = smbd.get_sys_acl(self.tempdir, smb_acl.SMB_ACL_TYPE_ACCESS, session_info)
LA_sid = security.dom_sid(str(domsid) + "-" + str(security.DOMAIN_RID_ADMINISTRATOR))
# configuration. When other environments have a broad range of
# groups mapped via passdb, we can relax some of these checks
(LA_uid, LA_type) = s4_passdb.sid_to_id(LA_sid)
- self.assertEquals(LA_type, idmap.ID_TYPE_UID)
+ self.assertEqual(LA_type, idmap.ID_TYPE_UID)
(BA_gid, BA_type) = s4_passdb.sid_to_id(BA_sid)
- self.assertEquals(BA_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(BA_type, idmap.ID_TYPE_BOTH)
(SO_gid, SO_type) = s4_passdb.sid_to_id(SO_sid)
- self.assertEquals(SO_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(SO_type, idmap.ID_TYPE_BOTH)
(SY_gid, SY_type) = s4_passdb.sid_to_id(SY_sid)
- self.assertEquals(SO_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(SO_type, idmap.ID_TYPE_BOTH)
(AU_gid, AU_type) = s4_passdb.sid_to_id(AU_sid)
- self.assertEquals(AU_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(AU_type, idmap.ID_TYPE_BOTH)
(PA_gid, PA_type) = s4_passdb.sid_to_id(PA_sid)
- self.assertEquals(PA_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(PA_type, idmap.ID_TYPE_BOTH)
- self.assertEquals(posix_acl.count, 15, self.print_posix_acl(posix_acl))
+ self.assertEqual(posix_acl.count, 15, self.print_posix_acl(posix_acl))
- self.assertEquals(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[0].a_perm, 7)
- self.assertEquals(posix_acl.acl[0].info.gid, BA_gid)
+ self.assertEqual(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[0].a_perm, 7)
+ self.assertEqual(posix_acl.acl[0].info.gid, BA_gid)
- self.assertEquals(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[1].a_perm, 7)
- self.assertEquals(posix_acl.acl[1].info.uid, LA_uid)
+ self.assertEqual(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[1].a_perm, 7)
+ self.assertEqual(posix_acl.acl[1].info.uid, LA_uid)
- self.assertEquals(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
- self.assertEquals(posix_acl.acl[2].a_perm, 0)
+ self.assertEqual(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
+ self.assertEqual(posix_acl.acl[2].a_perm, 0)
- self.assertEquals(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_USER_OBJ)
- self.assertEquals(posix_acl.acl[3].a_perm, 7)
+ self.assertEqual(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_USER_OBJ)
+ self.assertEqual(posix_acl.acl[3].a_perm, 7)
- self.assertEquals(posix_acl.acl[4].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[4].a_perm, 7)
- self.assertEquals(posix_acl.acl[4].info.uid, BA_gid)
+ self.assertEqual(posix_acl.acl[4].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[4].a_perm, 7)
+ self.assertEqual(posix_acl.acl[4].info.uid, BA_gid)
- self.assertEquals(posix_acl.acl[5].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
- self.assertEquals(posix_acl.acl[5].a_perm, 7)
+ self.assertEqual(posix_acl.acl[5].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
+ self.assertEqual(posix_acl.acl[5].a_perm, 7)
- self.assertEquals(posix_acl.acl[6].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[6].a_perm, 5)
- self.assertEquals(posix_acl.acl[6].info.uid, SO_gid)
+ self.assertEqual(posix_acl.acl[6].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[6].a_perm, 5)
+ self.assertEqual(posix_acl.acl[6].info.uid, SO_gid)
- self.assertEquals(posix_acl.acl[7].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[7].a_perm, 5)
- self.assertEquals(posix_acl.acl[7].info.gid, SO_gid)
+ self.assertEqual(posix_acl.acl[7].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[7].a_perm, 5)
+ self.assertEqual(posix_acl.acl[7].info.gid, SO_gid)
- self.assertEquals(posix_acl.acl[8].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[8].a_perm, 7)
- self.assertEquals(posix_acl.acl[8].info.uid, SY_gid)
+ self.assertEqual(posix_acl.acl[8].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[8].a_perm, 7)
+ self.assertEqual(posix_acl.acl[8].info.uid, SY_gid)
- self.assertEquals(posix_acl.acl[9].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[9].a_perm, 7)
- self.assertEquals(posix_acl.acl[9].info.gid, SY_gid)
+ self.assertEqual(posix_acl.acl[9].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[9].a_perm, 7)
+ self.assertEqual(posix_acl.acl[9].info.gid, SY_gid)
- self.assertEquals(posix_acl.acl[10].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[10].a_perm, 5)
- self.assertEquals(posix_acl.acl[10].info.uid, AU_gid)
+ self.assertEqual(posix_acl.acl[10].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[10].a_perm, 5)
+ self.assertEqual(posix_acl.acl[10].info.uid, AU_gid)
- self.assertEquals(posix_acl.acl[11].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[11].a_perm, 5)
- self.assertEquals(posix_acl.acl[11].info.gid, AU_gid)
+ self.assertEqual(posix_acl.acl[11].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[11].a_perm, 5)
+ self.assertEqual(posix_acl.acl[11].info.gid, AU_gid)
- self.assertEquals(posix_acl.acl[12].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[12].a_perm, 7)
- self.assertEquals(posix_acl.acl[12].info.uid, PA_gid)
+ self.assertEqual(posix_acl.acl[12].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[12].a_perm, 7)
+ self.assertEqual(posix_acl.acl[12].info.uid, PA_gid)
- self.assertEquals(posix_acl.acl[13].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[13].a_perm, 7)
- self.assertEquals(posix_acl.acl[13].info.gid, PA_gid)
+ self.assertEqual(posix_acl.acl[13].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[13].a_perm, 7)
+ self.assertEqual(posix_acl.acl[13].info.gid, PA_gid)
- self.assertEquals(posix_acl.acl[14].a_type, smb_acl.SMB_ACL_MASK)
- self.assertEquals(posix_acl.acl[14].a_perm, 7)
+ self.assertEqual(posix_acl.acl[14].a_type, smb_acl.SMB_ACL_MASK)
+ self.assertEqual(posix_acl.acl[14].a_perm, 7)
# check that it matches:
# user::rwx
setntacl(self.lp, self.tempf, acl, str(domsid),
session_info, use_ntvfs=False)
facl = getntacl(self.lp, self.tempf, session_info)
- self.assertEquals(facl.as_sddl(domsid), acl)
+ self.assertEqual(facl.as_sddl(domsid), acl)
posix_acl = smbd.get_sys_acl(self.tempf, smb_acl.SMB_ACL_TYPE_ACCESS, session_info)
nwrap_module_so_path = os.getenv('NSS_WRAPPER_MODULE_SO_PATH')
# configuration. When other environments have a broad range of
# groups mapped via passdb, we can relax some of these checks
(LA_uid, LA_type) = s4_passdb.sid_to_id(LA_sid)
- self.assertEquals(LA_type, idmap.ID_TYPE_UID)
+ self.assertEqual(LA_type, idmap.ID_TYPE_UID)
(BA_gid, BA_type) = s4_passdb.sid_to_id(BA_sid)
- self.assertEquals(BA_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(BA_type, idmap.ID_TYPE_BOTH)
(SO_gid, SO_type) = s4_passdb.sid_to_id(SO_sid)
- self.assertEquals(SO_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(SO_type, idmap.ID_TYPE_BOTH)
(SY_gid, SY_type) = s4_passdb.sid_to_id(SY_sid)
- self.assertEquals(SO_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(SO_type, idmap.ID_TYPE_BOTH)
(AU_gid, AU_type) = s4_passdb.sid_to_id(AU_sid)
- self.assertEquals(AU_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(AU_type, idmap.ID_TYPE_BOTH)
(PA_gid, PA_type) = s4_passdb.sid_to_id(PA_sid)
- self.assertEquals(PA_type, idmap.ID_TYPE_BOTH)
+ self.assertEqual(PA_type, idmap.ID_TYPE_BOTH)
- self.assertEquals(posix_acl.count, 15, self.print_posix_acl(posix_acl))
+ self.assertEqual(posix_acl.count, 15, self.print_posix_acl(posix_acl))
- self.assertEquals(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[0].a_perm, 7)
- self.assertEquals(posix_acl.acl[0].info.gid, BA_gid)
+ self.assertEqual(posix_acl.acl[0].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[0].a_perm, 7)
+ self.assertEqual(posix_acl.acl[0].info.gid, BA_gid)
- self.assertEquals(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[1].a_type, smb_acl.SMB_ACL_USER)
if nwrap_winbind_active or is_user_session:
- self.assertEquals(posix_acl.acl[1].a_perm, 7)
+ self.assertEqual(posix_acl.acl[1].a_perm, 7)
else:
- self.assertEquals(posix_acl.acl[1].a_perm, 6)
- self.assertEquals(posix_acl.acl[1].info.uid, LA_uid)
+ self.assertEqual(posix_acl.acl[1].a_perm, 6)
+ self.assertEqual(posix_acl.acl[1].info.uid, LA_uid)
- self.assertEquals(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
- self.assertEquals(posix_acl.acl[2].a_perm, 0)
+ self.assertEqual(posix_acl.acl[2].a_type, smb_acl.SMB_ACL_OTHER)
+ self.assertEqual(posix_acl.acl[2].a_perm, 0)
- self.assertEquals(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_USER_OBJ)
+ self.assertEqual(posix_acl.acl[3].a_type, smb_acl.SMB_ACL_USER_OBJ)
if nwrap_winbind_active or is_user_session:
- self.assertEquals(posix_acl.acl[3].a_perm, 7)
+ self.assertEqual(posix_acl.acl[3].a_perm, 7)
else:
- self.assertEquals(posix_acl.acl[3].a_perm, 6)
+ self.assertEqual(posix_acl.acl[3].a_perm, 6)
- self.assertEquals(posix_acl.acl[4].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[4].a_perm, 7)
- self.assertEquals(posix_acl.acl[4].info.uid, BA_gid)
+ self.assertEqual(posix_acl.acl[4].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[4].a_perm, 7)
+ self.assertEqual(posix_acl.acl[4].info.uid, BA_gid)
- self.assertEquals(posix_acl.acl[5].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
- self.assertEquals(posix_acl.acl[5].a_perm, 7)
+ self.assertEqual(posix_acl.acl[5].a_type, smb_acl.SMB_ACL_GROUP_OBJ)
+ self.assertEqual(posix_acl.acl[5].a_perm, 7)
- self.assertEquals(posix_acl.acl[6].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[6].a_perm, 5)
- self.assertEquals(posix_acl.acl[6].info.uid, SO_gid)
+ self.assertEqual(posix_acl.acl[6].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[6].a_perm, 5)
+ self.assertEqual(posix_acl.acl[6].info.uid, SO_gid)
- self.assertEquals(posix_acl.acl[7].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[7].a_perm, 5)
- self.assertEquals(posix_acl.acl[7].info.gid, SO_gid)
+ self.assertEqual(posix_acl.acl[7].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[7].a_perm, 5)
+ self.assertEqual(posix_acl.acl[7].info.gid, SO_gid)
- self.assertEquals(posix_acl.acl[8].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[8].a_perm, 7)
- self.assertEquals(posix_acl.acl[8].info.uid, SY_gid)
+ self.assertEqual(posix_acl.acl[8].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[8].a_perm, 7)
+ self.assertEqual(posix_acl.acl[8].info.uid, SY_gid)
- self.assertEquals(posix_acl.acl[9].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[9].a_perm, 7)
- self.assertEquals(posix_acl.acl[9].info.gid, SY_gid)
+ self.assertEqual(posix_acl.acl[9].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[9].a_perm, 7)
+ self.assertEqual(posix_acl.acl[9].info.gid, SY_gid)
- self.assertEquals(posix_acl.acl[10].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[10].a_perm, 5)
- self.assertEquals(posix_acl.acl[10].info.uid, AU_gid)
+ self.assertEqual(posix_acl.acl[10].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[10].a_perm, 5)
+ self.assertEqual(posix_acl.acl[10].info.uid, AU_gid)
- self.assertEquals(posix_acl.acl[11].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[11].a_perm, 5)
- self.assertEquals(posix_acl.acl[11].info.gid, AU_gid)
+ self.assertEqual(posix_acl.acl[11].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[11].a_perm, 5)
+ self.assertEqual(posix_acl.acl[11].info.gid, AU_gid)
- self.assertEquals(posix_acl.acl[12].a_type, smb_acl.SMB_ACL_USER)
- self.assertEquals(posix_acl.acl[12].a_perm, 7)
- self.assertEquals(posix_acl.acl[12].info.uid, PA_gid)
+ self.assertEqual(posix_acl.acl[12].a_type, smb_acl.SMB_ACL_USER)
+ self.assertEqual(posix_acl.acl[12].a_perm, 7)
+ self.assertEqual(posix_acl.acl[12].info.uid, PA_gid)
- self.assertEquals(posix_acl.acl[13].a_type, smb_acl.SMB_ACL_GROUP)
- self.assertEquals(posix_acl.acl[13].a_perm, 7)
- self.assertEquals(posix_acl.acl[13].info.gid, PA_gid)
+ self.assertEqual(posix_acl.acl[13].a_type, smb_acl.SMB_ACL_GROUP)
+ self.assertEqual(posix_acl.acl[13].a_perm, 7)
+ self.assertEqual(posix_acl.acl[13].info.gid, PA_gid)
- self.assertEquals(posix_acl.acl[14].a_type, smb_acl.SMB_ACL_MASK)
- self.assertEquals(posix_acl.acl[14].a_perm, 7)
+ self.assertEqual(posix_acl.acl[14].a_type, smb_acl.SMB_ACL_MASK)
+ self.assertEqual(posix_acl.acl[14].a_perm, 7)
# check that it matches:
# user::rwx
def rpc_echo(self):
conn = echo.rpcecho("ncalrpc:", self.get_loadparm())
- self.assertEquals([1, 2, 3], conn.EchoData([1, 2, 3]))
+ self.assertEqual([1, 2, 3], conn.EchoData([1, 2, 3]))
def netlogon(self):
server = os.environ["SERVER"]
self.assertIsNotNone(new_pid)
# check that the pid has not changed
- self.assertEquals(pid, new_pid)
+ self.assertEqual(pid, new_pid)
# check that the worker processes have restarted
new_workers = self.get_worker_pids("ldap", NUM_WORKERS)
# process 0 should have a new pid the others should be unchanged
self.assertNotEquals(workers[0], new_workers[0])
- self.assertEquals(workers[1], new_workers[1])
- self.assertEquals(workers[2], new_workers[2])
- self.assertEquals(workers[3], new_workers[3])
+ self.assertEqual(workers[1], new_workers[1])
+ self.assertEqual(workers[2], new_workers[2])
+ self.assertEqual(workers[3], new_workers[3])
# check that the previous server entries have been removed.
self.check_for_duplicate_processes()
self.assertIsNotNone(new_pid)
# check that the pid has not changed
- self.assertEquals(pid, new_pid)
+ self.assertEqual(pid, new_pid)
# check that the worker processes have restarted
new_workers = self.get_worker_pids("ldap", NUM_WORKERS)
self.assertIsNotNone(new_pid)
# check that the pid has not changed
- self.assertEquals(pid, new_pid)
+ self.assertEqual(pid, new_pid)
# check that the worker processes have restarted
new_workers = self.get_worker_pids("rpc", NUM_WORKERS)
# process 0 should have a new pid the others should be unchanged
self.assertNotEquals(workers[0], new_workers[0])
- self.assertEquals(workers[1], new_workers[1])
- self.assertEquals(workers[2], new_workers[2])
- self.assertEquals(workers[3], new_workers[3])
+ self.assertEqual(workers[1], new_workers[1])
+ self.assertEqual(workers[2], new_workers[2])
+ self.assertEqual(workers[3], new_workers[3])
# check that the previous server entries have been removed.
self.check_for_duplicate_processes()
self.assertIsNotNone(new_pid)
# check that the pid has not changed
- self.assertEquals(pid, new_pid)
+ self.assertEqual(pid, new_pid)
# check that the worker processes have restarted
new_workers = self.get_worker_pids("rpc", NUM_WORKERS)
paths.dns_keytab = "no.dns.keytab"
ldb = setup_secretsdb(paths, None, None, lp=env_loadparm())
try:
- self.assertEquals("LSA Secrets",
+ self.assertEqual("LSA Secrets",
ldb.searchone(basedn="CN=LSA Secrets", attribute="CN").decode('utf8'))
finally:
del ldb
self.assertRaises(KeyError, findnss, x, [])
def test_first(self):
- self.assertEquals("bla", findnss(lambda x: "bla", ["bla"]))
+ self.assertEqual("bla", findnss(lambda x: "bla", ["bla"]))
def test_skip_first(self):
def x(y):
if y != "bla":
raise KeyError
return "ha"
- self.assertEquals("ha", findnss(x, ["bloe", "bla"]))
+ self.assertEqual("ha", findnss(x, ["bloe", "bla"]))
class Disabled(object):
class SanitizeServerRoleTests(TestCase):
def test_same(self):
- self.assertEquals("standalone server",
+ self.assertEqual("standalone server",
sanitize_server_role("standalone server"))
- self.assertEquals("member server",
+ self.assertEqual("member server",
sanitize_server_role("member server"))
def test_invalid(self):
self.assertRaises(ValueError, sanitize_server_role, "foo")
def test_valid(self):
- self.assertEquals(
+ self.assertEqual(
"standalone server",
sanitize_server_role("ROLE_STANDALONE"))
- self.assertEquals(
+ self.assertEqual(
"standalone server",
sanitize_server_role("standalone"))
- self.assertEquals(
+ self.assertEqual(
"active directory domain controller",
sanitize_server_role("domain controller"))
def test_basic_report_logger(self):
result = self.base_result()
entries = self.report_logger(result)
- self.assertEquals(entries, [
+ self.assertEqual(entries, [
('INFO', 'Once the above files are installed, your Samba AD server '
'will be ready to use'),
('INFO', 'Server Role: domain controller'),
result.adminpass_generated = True
result.adminpass = "geheim"
entries = self.report_logger(result)
- self.assertEquals(entries[1],
+ self.assertEqual(entries[1],
("INFO", 'Admin password: geheim'))
class DetermineNetbiosNameTests(TestCase):
def test_limits_to_15(self):
- self.assertEquals("A" * 15, determine_netbios_name("a" * 30))
+ self.assertEqual("A" * 15, determine_netbios_name("a" * 30))
def test_strips_invalid(self):
- self.assertEquals("BLABLA", determine_netbios_name("bla/bla"))
+ self.assertEqual("BLABLA", determine_netbios_name("bla/bla"))
class HelperTests(samba.tests.TestCase):
def test_predef_to_name(self):
- self.assertEquals("HKEY_LOCAL_MACHINE",
+ self.assertEqual("HKEY_LOCAL_MACHINE",
registry.get_predef_name(0x80000002))
def test_str_regtype(self):
- self.assertEquals("REG_DWORD", registry.str_regtype(4))
+ self.assertEqual("REG_DWORD", registry.str_regtype(4))
class HiveTests(samba.tests.TestCaseInTempDir):
"winbindd_idmap"))
def test_user_hwm(self):
- self.assertEquals(10000, self.idmapdb.get_user_hwm())
+ self.assertEqual(10000, self.idmapdb.get_user_hwm())
def test_group_hwm(self):
- self.assertEquals(10002, self.idmapdb.get_group_hwm())
+ self.assertEqual(10002, self.idmapdb.get_group_hwm())
def test_uids(self):
- self.assertEquals(1, len(list(self.idmapdb.uids())))
+ self.assertEqual(1, len(list(self.idmapdb.uids())))
def test_gids(self):
- self.assertEquals(3, len(list(self.idmapdb.gids())))
+ self.assertEqual(3, len(list(self.idmapdb.gids())))
def test_get_user_sid(self):
- self.assertEquals(b"S-1-5-21-58189338-3053988021-627566699-501", self.idmapdb.get_user_sid(65534))
+ self.assertEqual(b"S-1-5-21-58189338-3053988021-627566699-501", self.idmapdb.get_user_sid(65534))
def test_get_group_sid(self):
- self.assertEquals(b"S-1-5-21-2447931902-1787058256-3961074038-3007", self.idmapdb.get_group_sid(10001))
+ self.assertEqual(b"S-1-5-21-2447931902-1787058256-3961074038-3007", self.idmapdb.get_group_sid(10001))
def tearDown(self):
self.idmapdb.close()
super(ParamTestCase, self).tearDown()
def test_param(self):
- self.assertEquals("BEDWYR", self.lp.get("netbios name"))
- self.assertEquals("SAMBA", self.lp.get("workgroup"))
- self.assertEquals("USER", self.lp.get("security"))
- self.assertEquals("/mnt/cd1", self.lp.get("path", "cd1"))
+ self.assertEqual("BEDWYR", self.lp.get("netbios name"))
+ self.assertEqual("SAMBA", self.lp.get("workgroup"))
+ self.assertEqual("USER", self.lp.get("security"))
+ self.assertEqual("/mnt/cd1", self.lp.get("path", "cd1"))
def test_policy(self):
policy = self.pdb.get_account_policy()
- self.assertEquals(0, policy['bad lockout attempt'])
- self.assertEquals(-1, policy['disconnect time'])
- self.assertEquals(0, policy['lockout duration'])
- self.assertEquals(999999999, policy['maximum password age'])
- self.assertEquals(0, policy['minimum password age'])
- self.assertEquals(5, policy['min password length'])
- self.assertEquals(0, policy['password history'])
- self.assertEquals(0, policy['refuse machine password change'])
- self.assertEquals(0, policy['reset count minutes'])
- self.assertEquals(0, policy['user must logon to change password'])
+ self.assertEqual(0, policy['bad lockout attempt'])
+ self.assertEqual(-1, policy['disconnect time'])
+ self.assertEqual(0, policy['lockout duration'])
+ self.assertEqual(999999999, policy['maximum password age'])
+ self.assertEqual(0, policy['minimum password age'])
+ self.assertEqual(5, policy['min password length'])
+ self.assertEqual(0, policy['password history'])
+ self.assertEqual(0, policy['refuse machine password change'])
+ self.assertEqual(0, policy['reset count minutes'])
+ self.assertEqual(0, policy['user must logon to change password'])
def test_get_sid(self):
domain_sid = passdb.get_global_sam_sid()
- self.assertEquals(dom_sid("S-1-5-21-2470180966-3899876309-2637894779"), domain_sid)
+ self.assertEqual(dom_sid("S-1-5-21-2470180966-3899876309-2637894779"), domain_sid)
def test_usernames(self):
userlist = self.pdb.search_users(0)
- self.assertEquals(3, len(userlist))
+ self.assertEqual(3, len(userlist))
def test_getuser(self):
user = self.pdb.getsampwnam("root")
- self.assertEquals(16, user.acct_ctrl)
- self.assertEquals("", user.acct_desc)
- self.assertEquals(0, user.bad_password_count)
- self.assertEquals(0, user.bad_password_time)
- self.assertEquals(0, user.code_page)
- self.assertEquals(0, user.country_code)
- self.assertEquals("", user.dir_drive)
- self.assertEquals("BEDWYR", user.domain)
- self.assertEquals("root", user.full_name)
- self.assertEquals(dom_sid('S-1-5-21-2470180966-3899876309-2637894779-513'), user.group_sid)
- self.assertEquals("\\\\BEDWYR\\root", user.home_dir)
- self.assertEquals([-1 for i in range(21)], user.hours)
- self.assertEquals(21, user.hours_len)
- self.assertEquals(9223372036854775807, user.kickoff_time)
- self.assertEquals(None, user.lanman_passwd)
- self.assertEquals(9223372036854775807, user.logoff_time)
- self.assertEquals(0, user.logon_count)
- self.assertEquals(168, user.logon_divs)
- self.assertEquals("", user.logon_script)
- self.assertEquals(0, user.logon_time)
- self.assertEquals("", user.munged_dial)
- self.assertEquals(b'\x87\x8d\x80\x14`l\xda)gzD\xef\xa15?\xc7', user.nt_passwd)
- self.assertEquals("", user.nt_username)
- self.assertEquals(1125418267, user.pass_can_change_time)
- self.assertEquals(1125418267, user.pass_last_set_time)
- self.assertEquals(2125418266, user.pass_must_change_time)
- self.assertEquals(None, user.plaintext_passwd)
- self.assertEquals("\\\\BEDWYR\\root\\profile", user.profile_path)
- self.assertEquals(None, user.pw_history)
- self.assertEquals(dom_sid("S-1-5-21-2470180966-3899876309-2637894779-1000"), user.user_sid)
- self.assertEquals("root", user.username)
- self.assertEquals("", user.workstations)
+ self.assertEqual(16, user.acct_ctrl)
+ self.assertEqual("", user.acct_desc)
+ self.assertEqual(0, user.bad_password_count)
+ self.assertEqual(0, user.bad_password_time)
+ self.assertEqual(0, user.code_page)
+ self.assertEqual(0, user.country_code)
+ self.assertEqual("", user.dir_drive)
+ self.assertEqual("BEDWYR", user.domain)
+ self.assertEqual("root", user.full_name)
+ self.assertEqual(dom_sid('S-1-5-21-2470180966-3899876309-2637894779-513'), user.group_sid)
+ self.assertEqual("\\\\BEDWYR\\root", user.home_dir)
+ self.assertEqual([-1 for i in range(21)], user.hours)
+ self.assertEqual(21, user.hours_len)
+ self.assertEqual(9223372036854775807, user.kickoff_time)
+ self.assertEqual(None, user.lanman_passwd)
+ self.assertEqual(9223372036854775807, user.logoff_time)
+ self.assertEqual(0, user.logon_count)
+ self.assertEqual(168, user.logon_divs)
+ self.assertEqual("", user.logon_script)
+ self.assertEqual(0, user.logon_time)
+ self.assertEqual("", user.munged_dial)
+ self.assertEqual(b'\x87\x8d\x80\x14`l\xda)gzD\xef\xa15?\xc7', user.nt_passwd)
+ self.assertEqual("", user.nt_username)
+ self.assertEqual(1125418267, user.pass_can_change_time)
+ self.assertEqual(1125418267, user.pass_last_set_time)
+ self.assertEqual(2125418266, user.pass_must_change_time)
+ self.assertEqual(None, user.plaintext_passwd)
+ self.assertEqual("\\\\BEDWYR\\root\\profile", user.profile_path)
+ self.assertEqual(None, user.pw_history)
+ self.assertEqual(dom_sid("S-1-5-21-2470180966-3899876309-2637894779-1000"), user.user_sid)
+ self.assertEqual("root", user.username)
+ self.assertEqual("", user.workstations)
def test_group_length(self):
grouplist = self.pdb.enum_group_mapping()
- self.assertEquals(13, len(grouplist))
+ self.assertEqual(13, len(grouplist))
def test_get_group(self):
group = self.pdb.getgrsid(dom_sid("S-1-5-32-544"))
- self.assertEquals("Administrators", group.nt_name)
- self.assertEquals(-1, group.gid)
- self.assertEquals(5, group.sid_name_use)
+ self.assertEqual("Administrators", group.nt_name)
+ self.assertEqual(-1, group.gid)
+ self.assertEqual(5, group.sid_name_use)
def test_groupsids(self):
grouplist = self.pdb.enum_group_mapping()
def test_alias_length(self):
aliaslist = self.pdb.search_aliases()
- self.assertEquals(1, len(aliaslist))
- self.assertEquals("Jelmers NT Group", aliaslist[0]['account_name'])
+ self.assertEqual(1, len(aliaslist))
+ self.assertEqual("Jelmers NT Group", aliaslist[0]['account_name'])
super(RegistryTestCase, self).tearDown()
def test_length(self):
- self.assertEquals(28, len(self.registry))
+ self.assertEqual(28, len(self.registry))
def test_keys(self):
self.assertTrue(b"HKLM" in self.registry.keys())
def test_subkeys(self):
- self.assertEquals([b"SOFTWARE", b"SYSTEM"], self.registry.subkeys(b"HKLM"))
+ self.assertEqual([b"SOFTWARE", b"SYSTEM"], self.registry.subkeys(b"HKLM"))
def test_values(self):
- self.assertEquals({b'DisplayName': (1, b'E\x00v\x00e\x00n\x00t\x00 \x00L\x00o\x00g\x00\x00\x00'),
+ self.assertEqual({b'DisplayName': (1, b'E\x00v\x00e\x00n\x00t\x00 \x00L\x00o\x00g\x00\x00\x00'),
b'ErrorControl': (4, b'\x01\x00\x00\x00')},
self.registry.values(b"HKLM/SYSTEM/CURRENTCONTROLSET/SERVICES/EVENTLOG"))
self.winsdb = WinsDatabase(os.path.join(DATADIR, "wins.dat"))
def test_length(self):
- self.assertEquals(22, len(self.winsdb))
+ self.assertEqual(22, len(self.winsdb))
def test_first_entry(self):
self.assertEqual((1124185120, ["192.168.1.5"], 0x64), self.winsdb["ADMINISTRATOR#03"])
sid_obj1 = samba.ndr.ndr_unpack(samba.dcerpc.security.dom_sid,
ndr_sid[0])
sid_obj2 = samba.dcerpc.security.dom_sid(text)
- self.assertEquals(sid_obj1, sid_obj2)
+ self.assertEqual(sid_obj1, sid_obj2)
class Samba3SamTestCase(MapBaseTestCase):
def test_search_non_mapped(self):
"""Looking up by non-mapped attribute"""
msg = self.ldb.search(expression="(cn=Administrator)")
- self.assertEquals(len(msg), 1)
- self.assertEquals(str(msg[0]["cn"]), "Administrator")
+ self.assertEqual(len(msg), 1)
+ self.assertEqual(str(msg[0]["cn"]), "Administrator")
def test_search_mapped(self):
"""Looking up by mapped attribute"""
msg = self.ldb.search(expression="(name=Backup Operators)")
- self.assertEquals(len(msg), 1)
- self.assertEquals(str(msg[0]["name"]), "Backup Operators")
+ self.assertEqual(len(msg), 1)
+ self.assertEqual(str(msg[0]["name"]), "Backup Operators")
def test_old_name_of_renamed(self):
"""Looking up by old name of renamed attribute"""
msg = self.ldb.search(expression="(displayName=Backup Operators)")
- self.assertEquals(len(msg), 0)
+ self.assertEqual(len(msg), 0)
def test_mapped_containing_sid(self):
"""Looking up mapped entry containing SID"""
msg = self.ldb.search(expression="(cn=Replicator)")
- self.assertEquals(len(msg), 1)
- self.assertEquals(str(msg[0].dn),
+ self.assertEqual(len(msg), 1)
+ self.assertEqual(str(msg[0].dn),
"cn=Replicator,ou=Groups,dc=vernstok,dc=nl")
self.assertTrue("objectSid" in msg[0])
self.assertSidEquals("S-1-5-21-4231626423-2410014848-2360679739-1052",
msg[0]["objectSid"])
oc = set(msg[0]["objectClass"])
- self.assertEquals(oc, set([b"group"]))
+ self.assertEqual(oc, set([b"group"]))
def test_search_by_objclass(self):
"""Looking up by objectClass"""
msg = self.ldb.search(expression="(|(objectClass=user)(cn=Administrator))")
- self.assertEquals(set([str(m.dn) for m in msg]),
+ self.assertEqual(set([str(m.dn) for m in msg]),
set(["unixName=Administrator,ou=Users,dc=vernstok,dc=nl",
"unixName=nobody,ou=Users,dc=vernstok,dc=nl"]))
msg = self.ldb.search(expression="(cn=Foo)", base="cn=Foo",
scope=SCOPE_BASE,
attrs=['foo', 'blah', 'cn', 'showInAdvancedViewOnly'])
- self.assertEquals(len(msg), 1)
- self.assertEquals(str(msg[0]["showInAdvancedViewOnly"]), "TRUE")
- self.assertEquals(str(msg[0]["foo"]), "bar")
- self.assertEquals(str(msg[0]["blah"]), "Blie")
+ self.assertEqual(len(msg), 1)
+ self.assertEqual(str(msg[0]["showInAdvancedViewOnly"]), "TRUE")
+ self.assertEqual(str(msg[0]["foo"]), "bar")
+ self.assertEqual(str(msg[0]["blah"]), "Blie")
# Adding record that will be mapped
self.ldb.add({"dn": "cn=Niemand,cn=Users,dc=vernstok,dc=nl",
# Checking for existence of record (remote)
msg = self.ldb.search(expression="(unixName=bin)",
attrs=['unixName', 'cn', 'dn', 'sambaUnicodePwd'])
- self.assertEquals(len(msg), 1)
- self.assertEquals(str(msg[0]["cn"]), "Niemand")
- self.assertEquals(str(msg[0]["sambaUnicodePwd"]), "geheim")
+ self.assertEqual(len(msg), 1)
+ self.assertEqual(str(msg[0]["cn"]), "Niemand")
+ self.assertEqual(str(msg[0]["sambaUnicodePwd"]), "geheim")
# Checking for existence of record (local && remote)
msg = self.ldb.search(expression="(&(unixName=bin)(sambaUnicodePwd=geheim))",
attrs=['unixName', 'cn', 'dn', 'sambaUnicodePwd'])
- self.assertEquals(len(msg), 1) # TODO: should check with more records
- self.assertEquals(str(msg[0]["cn"]), "Niemand")
- self.assertEquals(str(msg[0]["unixName"]), "bin")
- self.assertEquals(str(msg[0]["sambaUnicodePwd"]), "geheim")
+ self.assertEqual(len(msg), 1) # TODO: should check with more records
+ self.assertEqual(str(msg[0]["cn"]), "Niemand")
+ self.assertEqual(str(msg[0]["unixName"]), "bin")
+ self.assertEqual(str(msg[0]["sambaUnicodePwd"]), "geheim")
# Checking for existence of record (local || remote)
msg = self.ldb.search(expression="(|(unixName=bin)(sambaUnicodePwd=geheim))",
attrs=['unixName', 'cn', 'dn', 'sambaUnicodePwd'])
# print "got %d replies" % len(msg)
- self.assertEquals(len(msg), 1) # TODO: should check with more records
- self.assertEquals(str(msg[0]["cn"]), "Niemand")
- self.assertEquals(str(msg[0]["unixName"]), "bin")
- self.assertEquals(str(msg[0]["sambaUnicodePwd"]), "geheim")
+ self.assertEqual(len(msg), 1) # TODO: should check with more records
+ self.assertEqual(str(msg[0]["cn"]), "Niemand")
+ self.assertEqual(str(msg[0]["unixName"]), "bin")
+ self.assertEqual(str(msg[0]["sambaUnicodePwd"]), "geheim")
# Checking for data in destination database
msg = self.samba3.db.search(expression="(cn=Niemand)")
self.assertTrue(len(msg) >= 1)
- self.assertEquals(str(msg[0]["sambaSID"]),
+ self.assertEqual(str(msg[0]["sambaSID"]),
"S-1-5-21-4231626423-2410014848-2360679739-2001")
- self.assertEquals(str(msg[0]["displayName"]), "Niemand")
+ self.assertEqual(str(msg[0]["displayName"]), "Niemand")
# Adding attribute...
self.ldb.modify_ldif("""
# Checking whether changes are still there...
msg = self.ldb.search(expression="(cn=Niemand)")
self.assertTrue(len(msg) >= 1)
- self.assertEquals(str(msg[0]["cn"]), "Niemand")
- self.assertEquals(str(msg[0]["description"]), "Blah")
+ self.assertEqual(str(msg[0]["cn"]), "Niemand")
+ self.assertEqual(str(msg[0]["description"]), "Blah")
# Modifying attribute...
self.ldb.modify_ldif("""
# Checking whether changes are still there...
msg = self.ldb.search(expression="(cn=Niemand)")
self.assertTrue(len(msg) >= 1)
- self.assertEquals(str(msg[0]["description"]), "Blie")
+ self.assertEqual(str(msg[0]["description"]), "Blie")
# Deleting attribute...
self.ldb.modify_ldif("""
# Checking whether DN has changed...
msg = self.ldb.search(expression="(cn=Niemand2)")
- self.assertEquals(len(msg), 1)
- self.assertEquals(str(msg[0].dn),
+ self.assertEqual(len(msg), 1)
+ self.assertEqual(str(msg[0].dn),
"cn=Niemand2,cn=Users,dc=vernstok,dc=nl")
# Deleting record...
# Checking whether record is gone...
msg = self.ldb.search(expression="(cn=Niemand2)")
- self.assertEquals(len(msg), 0)
+ self.assertEqual(len(msg), 0)
class MapTestCase(MapBaseTestCase):
dn = self.samba4.dn("cn=A")
res = self.ldb.search(dn, scope=SCOPE_BASE,
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
# Search remote record by remote DN
dn = self.samba3.dn("cn=A")
res = self.samba3.db.search(dn, scope=SCOPE_BASE,
attrs=["dnsHostName", "lastLogon", "sambaLogonTime"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
self.assertTrue("dnsHostName" not in res[0])
self.assertTrue("lastLogon" not in res[0])
- self.assertEquals(str(res[0]["sambaLogonTime"]), "x")
+ self.assertEqual(str(res[0]["sambaLogonTime"]), "x")
# Search split record by local DN
dn = self.samba4.dn("cn=X")
res = self.ldb.search(dn, scope=SCOPE_BASE,
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(str(res[0]["dnsHostName"]), "x")
- self.assertEquals(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
+ self.assertEqual(str(res[0]["dnsHostName"]), "x")
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
# Search split record by remote DN
dn = self.samba3.dn("cn=X")
res = self.samba3.db.search(dn, scope=SCOPE_BASE,
attrs=["dnsHostName", "lastLogon", "sambaLogonTime"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
self.assertTrue("dnsHostName" not in res[0])
self.assertTrue("lastLogon" not in res[0])
- self.assertEquals(str(res[0]["sambaLogonTime"]), "x")
+ self.assertEqual(str(res[0]["sambaLogonTime"]), "x")
# Testing search by attribute
# Search by ignored attribute
res = self.ldb.search(expression="(revision=x)", scope=SCOPE_DEFAULT,
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 2)
+ self.assertEqual(len(res), 2)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=X"))
- self.assertEquals(str(res[0]["dnsHostName"]), "x")
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=Y"))
- self.assertEquals(str(res[1]["dnsHostName"]), "y")
- self.assertEquals(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=X"))
+ self.assertEqual(str(res[0]["dnsHostName"]), "x")
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=Y"))
+ self.assertEqual(str(res[1]["dnsHostName"]), "y")
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
# Search by kept attribute
res = self.ldb.search(expression="(description=y)",
scope=SCOPE_DEFAULT, attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 2)
+ self.assertEqual(len(res), 2)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=C"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=C"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "z")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=Z"))
- self.assertEquals(str(res[1]["dnsHostName"]), "z")
- self.assertEquals(str(res[1]["lastLogon"]), "z")
+ self.assertEqual(str(res[0]["lastLogon"]), "z")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=Z"))
+ self.assertEqual(str(res[1]["dnsHostName"]), "z")
+ self.assertEqual(str(res[1]["lastLogon"]), "z")
# Search by renamed attribute
res = self.ldb.search(expression="(badPwdCount=x)", scope=SCOPE_DEFAULT,
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 2)
+ self.assertEqual(len(res), 2)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=B"))
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=B"))
self.assertTrue("dnsHostName" not in res[1])
- self.assertEquals(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
# Search by converted attribute
# TODO:
# errors, letting the search fail with no results.
# res = self.ldb.search("(objectSid=S-1-5-21-4231626423-2410014848-2360679739-1052)", scope=SCOPE_DEFAULT, attrs)
res = self.ldb.search(expression="(objectSid=*)", base=None, scope=SCOPE_DEFAULT, attrs=["dnsHostName", "lastLogon", "objectSid"])
- self.assertEquals(len(res), 4)
+ self.assertEqual(len(res), 4)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
- self.assertEquals(str(res[1]["dnsHostName"]), "x")
- self.assertEquals(str(res[1]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=X"))
+ self.assertEqual(str(res[1]["dnsHostName"]), "x")
+ self.assertEqual(str(res[1]["lastLogon"]), "x")
self.assertSidEquals("S-1-5-21-4231626423-2410014848-2360679739-1052",
res[1]["objectSid"])
self.assertTrue("objectSid" in res[1])
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
self.assertSidEquals("S-1-5-21-4231626423-2410014848-2360679739-1052",
res[0]["objectSid"])
self.assertTrue("objectSid" in res[0])
# a `convert_operator' by enumerating the remote db.
res = self.ldb.search(expression="(primaryGroupID=512)",
attrs=["dnsHostName", "lastLogon", "primaryGroupID"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[0]["primaryGroupID"]), "512")
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[0]["primaryGroupID"]), "512")
# Note that Xs "objectSid" seems to be fine in the previous search for
# "objectSid"...
# Search by remote name of renamed attribute */
res = self.ldb.search(expression="(sambaBadPasswordCount=*)",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# Search by objectClass
attrs = ["dnsHostName", "lastLogon", "objectClass"]
res = self.ldb.search(expression="(objectClass=user)", attrs=attrs)
- self.assertEquals(len(res), 2)
+ self.assertEqual(len(res), 2)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[0]["objectClass"][0]), "user")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
- self.assertEquals(str(res[1]["dnsHostName"]), "x")
- self.assertEquals(str(res[1]["lastLogon"]), "x")
- self.assertEquals(str(res[1]["objectClass"][0]), "user")
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[0]["objectClass"][0]), "user")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=X"))
+ self.assertEqual(str(res[1]["dnsHostName"]), "x")
+ self.assertEqual(str(res[1]["lastLogon"]), "x")
+ self.assertEqual(str(res[1]["objectClass"][0]), "user")
# Prove that the objectClass is actually used for the search
res = self.ldb.search(expression="(|(objectClass=user)(badPwdCount=x))",
attrs=attrs)
- self.assertEquals(len(res), 3)
+ self.assertEqual(len(res), 3)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[0]["objectClass"][0]), "user")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=B"))
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[0]["objectClass"][0]), "user")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=B"))
self.assertTrue("dnsHostName" not in res[1])
- self.assertEquals(str(res[1]["lastLogon"]), "y")
- self.assertEquals(set(res[1]["objectClass"]), set([b"top"]))
- self.assertEquals(str(res[2].dn), self.samba4.dn("cn=X"))
- self.assertEquals(str(res[2]["dnsHostName"]), "x")
- self.assertEquals(str(res[2]["lastLogon"]), "x")
- self.assertEquals(str(res[2]["objectClass"][0]), "user")
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(set(res[1]["objectClass"]), set([b"top"]))
+ self.assertEqual(str(res[2].dn), self.samba4.dn("cn=X"))
+ self.assertEqual(str(res[2]["dnsHostName"]), "x")
+ self.assertEqual(str(res[2]["lastLogon"]), "x")
+ self.assertEqual(str(res[2]["objectClass"][0]), "user")
# Testing search by parse tree
# Search by conjunction of local attributes
res = self.ldb.search(expression="(&(codePage=x)(revision=x))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 2)
+ self.assertEqual(len(res), 2)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=X"))
- self.assertEquals(str(res[0]["dnsHostName"]), "x")
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=Y"))
- self.assertEquals(str(res[1]["dnsHostName"]), "y")
- self.assertEquals(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=X"))
+ self.assertEqual(str(res[0]["dnsHostName"]), "x")
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=Y"))
+ self.assertEqual(str(res[1]["dnsHostName"]), "y")
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
# Search by conjunction of remote attributes
res = self.ldb.search(expression="(&(lastLogon=x)(description=x))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 2)
+ self.assertEqual(len(res), 2)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
- self.assertEquals(str(res[1]["dnsHostName"]), "x")
- self.assertEquals(str(res[1]["lastLogon"]), "x")
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=X"))
+ self.assertEqual(str(res[1]["dnsHostName"]), "x")
+ self.assertEqual(str(res[1]["lastLogon"]), "x")
# Search by conjunction of local and remote attribute
res = self.ldb.search(expression="(&(codePage=x)(description=x))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 2)
+ self.assertEqual(len(res), 2)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=X"))
- self.assertEquals(str(res[0]["dnsHostName"]), "x")
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=Y"))
- self.assertEquals(str(res[1]["dnsHostName"]), "y")
- self.assertEquals(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=X"))
+ self.assertEqual(str(res[0]["dnsHostName"]), "x")
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=Y"))
+ self.assertEqual(str(res[1]["dnsHostName"]), "y")
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
# Search by conjunction of local and remote attribute w/o match
attrs = ["dnsHostName", "lastLogon"]
res = self.ldb.search(expression="(&(codePage=x)(nextRid=x))",
attrs=attrs)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
res = self.ldb.search(expression="(&(revision=x)(lastLogon=z))",
attrs=attrs)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# Search by disjunction of local attributes
res = self.ldb.search(expression="(|(revision=x)(dnsHostName=x))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 2)
+ self.assertEqual(len(res), 2)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=X"))
- self.assertEquals(str(res[0]["dnsHostName"]), "x")
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=Y"))
- self.assertEquals(str(res[1]["dnsHostName"]), "y")
- self.assertEquals(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=X"))
+ self.assertEqual(str(res[0]["dnsHostName"]), "x")
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=Y"))
+ self.assertEqual(str(res[1]["dnsHostName"]), "y")
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
# Search by disjunction of remote attributes
res = self.ldb.search(expression="(|(badPwdCount=x)(lastLogon=x))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 3)
+ self.assertEqual(len(res), 3)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertFalse("dnsHostName" in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=B"))
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=B"))
self.assertFalse("dnsHostName" in res[1])
- self.assertEquals(str(res[1]["lastLogon"]), "y")
- self.assertEquals(str(res[2].dn), self.samba4.dn("cn=X"))
- self.assertEquals(str(res[2]["dnsHostName"]), "x")
- self.assertEquals(str(res[2]["lastLogon"]), "x")
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(str(res[2].dn), self.samba4.dn("cn=X"))
+ self.assertEqual(str(res[2]["dnsHostName"]), "x")
+ self.assertEqual(str(res[2]["lastLogon"]), "x")
# Search by disjunction of local and remote attribute
res = self.ldb.search(expression="(|(revision=x)(lastLogon=y))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 3)
+ self.assertEqual(len(res), 3)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=B"))
self.assertFalse("dnsHostName" in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "y")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
- self.assertEquals(str(res[1]["dnsHostName"]), "x")
- self.assertEquals(str(res[1]["lastLogon"]), "x")
- self.assertEquals(str(res[2].dn), self.samba4.dn("cn=Y"))
- self.assertEquals(str(res[2]["dnsHostName"]), "y")
- self.assertEquals(str(res[2]["lastLogon"]), "y")
+ self.assertEqual(str(res[0]["lastLogon"]), "y")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=X"))
+ self.assertEqual(str(res[1]["dnsHostName"]), "x")
+ self.assertEqual(str(res[1]["lastLogon"]), "x")
+ self.assertEqual(str(res[2].dn), self.samba4.dn("cn=Y"))
+ self.assertEqual(str(res[2]["dnsHostName"]), "y")
+ self.assertEqual(str(res[2]["lastLogon"]), "y")
# Search by disjunction of local and remote attribute w/o match
res = self.ldb.search(expression="(|(codePage=y)(nextRid=z))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# Search by negated local attribute
res = self.ldb.search(expression="(!(revision=x))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 6)
+ self.assertEqual(len(res), 6)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=B"))
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=B"))
self.assertTrue("dnsHostName" not in res[1])
- self.assertEquals(str(res[1]["lastLogon"]), "y")
- self.assertEquals(str(res[2].dn), self.samba4.dn("cn=C"))
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(str(res[2].dn), self.samba4.dn("cn=C"))
self.assertTrue("dnsHostName" not in res[2])
- self.assertEquals(str(res[2]["lastLogon"]), "z")
- self.assertEquals(str(res[3].dn), self.samba4.dn("cn=Z"))
- self.assertEquals(str(res[3]["dnsHostName"]), "z")
- self.assertEquals(str(res[3]["lastLogon"]), "z")
+ self.assertEqual(str(res[2]["lastLogon"]), "z")
+ self.assertEqual(str(res[3].dn), self.samba4.dn("cn=Z"))
+ self.assertEqual(str(res[3]["dnsHostName"]), "z")
+ self.assertEqual(str(res[3]["lastLogon"]), "z")
# Search by negated remote attribute
res = self.ldb.search(expression="(!(description=x))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 4)
+ self.assertEqual(len(res), 4)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=C"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=C"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "z")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=Z"))
- self.assertEquals(str(res[1]["dnsHostName"]), "z")
- self.assertEquals(str(res[1]["lastLogon"]), "z")
+ self.assertEqual(str(res[0]["lastLogon"]), "z")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=Z"))
+ self.assertEqual(str(res[1]["dnsHostName"]), "z")
+ self.assertEqual(str(res[1]["lastLogon"]), "z")
# Search by negated conjunction of local attributes
res = self.ldb.search(expression="(!(&(codePage=x)(revision=x)))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 6)
+ self.assertEqual(len(res), 6)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=B"))
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=B"))
self.assertTrue("dnsHostName" not in res[1])
- self.assertEquals(str(res[1]["lastLogon"]), "y")
- self.assertEquals(str(res[2].dn), self.samba4.dn("cn=C"))
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(str(res[2].dn), self.samba4.dn("cn=C"))
self.assertTrue("dnsHostName" not in res[2])
- self.assertEquals(str(res[2]["lastLogon"]), "z")
- self.assertEquals(str(res[3].dn), self.samba4.dn("cn=Z"))
- self.assertEquals(str(res[3]["dnsHostName"]), "z")
- self.assertEquals(str(res[3]["lastLogon"]), "z")
+ self.assertEqual(str(res[2]["lastLogon"]), "z")
+ self.assertEqual(str(res[3].dn), self.samba4.dn("cn=Z"))
+ self.assertEqual(str(res[3]["dnsHostName"]), "z")
+ self.assertEqual(str(res[3]["lastLogon"]), "z")
# Search by negated conjunction of remote attributes
res = self.ldb.search(expression="(!(&(lastLogon=x)(description=x)))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 6)
+ self.assertEqual(len(res), 6)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=B"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "y")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=C"))
+ self.assertEqual(str(res[0]["lastLogon"]), "y")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=C"))
self.assertTrue("dnsHostName" not in res[1])
- self.assertEquals(str(res[1]["lastLogon"]), "z")
- self.assertEquals(str(res[2].dn), self.samba4.dn("cn=Y"))
- self.assertEquals(str(res[2]["dnsHostName"]), "y")
- self.assertEquals(str(res[2]["lastLogon"]), "y")
- self.assertEquals(str(res[3].dn), self.samba4.dn("cn=Z"))
- self.assertEquals(str(res[3]["dnsHostName"]), "z")
- self.assertEquals(str(res[3]["lastLogon"]), "z")
+ self.assertEqual(str(res[1]["lastLogon"]), "z")
+ self.assertEqual(str(res[2].dn), self.samba4.dn("cn=Y"))
+ self.assertEqual(str(res[2]["dnsHostName"]), "y")
+ self.assertEqual(str(res[2]["lastLogon"]), "y")
+ self.assertEqual(str(res[3].dn), self.samba4.dn("cn=Z"))
+ self.assertEqual(str(res[3]["dnsHostName"]), "z")
+ self.assertEqual(str(res[3]["lastLogon"]), "z")
# Search by negated conjunction of local and remote attribute
res = self.ldb.search(expression="(!(&(codePage=x)(description=x)))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 6)
+ self.assertEqual(len(res), 6)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=B"))
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=B"))
self.assertTrue("dnsHostName" not in res[1])
- self.assertEquals(str(res[1]["lastLogon"]), "y")
- self.assertEquals(str(res[2].dn), self.samba4.dn("cn=C"))
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(str(res[2].dn), self.samba4.dn("cn=C"))
self.assertTrue("dnsHostName" not in res[2])
- self.assertEquals(str(res[2]["lastLogon"]), "z")
- self.assertEquals(str(res[3].dn), self.samba4.dn("cn=Z"))
- self.assertEquals(str(res[3]["dnsHostName"]), "z")
- self.assertEquals(str(res[3]["lastLogon"]), "z")
+ self.assertEqual(str(res[2]["lastLogon"]), "z")
+ self.assertEqual(str(res[3].dn), self.samba4.dn("cn=Z"))
+ self.assertEqual(str(res[3]["dnsHostName"]), "z")
+ self.assertEqual(str(res[3]["lastLogon"]), "z")
# Search by negated disjunction of local attributes
res = self.ldb.search(expression="(!(|(revision=x)(dnsHostName=x)))",
attrs=["dnsHostName", "lastLogon"])
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=B"))
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=B"))
self.assertTrue("dnsHostName" not in res[1])
- self.assertEquals(str(res[1]["lastLogon"]), "y")
- self.assertEquals(str(res[2].dn), self.samba4.dn("cn=C"))
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(str(res[2].dn), self.samba4.dn("cn=C"))
self.assertTrue("dnsHostName" not in res[2])
- self.assertEquals(str(res[2]["lastLogon"]), "z")
- self.assertEquals(str(res[3].dn), self.samba4.dn("cn=Z"))
- self.assertEquals(str(res[3]["dnsHostName"]), "z")
- self.assertEquals(str(res[3]["lastLogon"]), "z")
+ self.assertEqual(str(res[2]["lastLogon"]), "z")
+ self.assertEqual(str(res[3].dn), self.samba4.dn("cn=Z"))
+ self.assertEqual(str(res[3]["dnsHostName"]), "z")
+ self.assertEqual(str(res[3]["lastLogon"]), "z")
# Search by negated disjunction of remote attributes
res = self.ldb.search(expression="(!(|(badPwdCount=x)(lastLogon=x)))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 5)
+ self.assertEqual(len(res), 5)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=C"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=C"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "z")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=Y"))
- self.assertEquals(str(res[1]["dnsHostName"]), "y")
- self.assertEquals(str(res[1]["lastLogon"]), "y")
- self.assertEquals(str(res[2].dn), self.samba4.dn("cn=Z"))
- self.assertEquals(str(res[2]["dnsHostName"]), "z")
- self.assertEquals(str(res[2]["lastLogon"]), "z")
+ self.assertEqual(str(res[0]["lastLogon"]), "z")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=Y"))
+ self.assertEqual(str(res[1]["dnsHostName"]), "y")
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(str(res[2].dn), self.samba4.dn("cn=Z"))
+ self.assertEqual(str(res[2]["dnsHostName"]), "z")
+ self.assertEqual(str(res[2]["lastLogon"]), "z")
# Search by negated disjunction of local and remote attribute
res = self.ldb.search(expression="(!(|(revision=x)(lastLogon=y)))",
attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 5)
+ self.assertEqual(len(res), 5)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=C"))
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=C"))
self.assertTrue("dnsHostName" not in res[1])
- self.assertEquals(str(res[1]["lastLogon"]), "z")
- self.assertEquals(str(res[2].dn), self.samba4.dn("cn=Z"))
- self.assertEquals(str(res[2]["dnsHostName"]), "z")
- self.assertEquals(str(res[2]["lastLogon"]), "z")
+ self.assertEqual(str(res[1]["lastLogon"]), "z")
+ self.assertEqual(str(res[2].dn), self.samba4.dn("cn=Z"))
+ self.assertEqual(str(res[2]["dnsHostName"]), "z")
+ self.assertEqual(str(res[2]["lastLogon"]), "z")
# Search by complex parse tree
res = self.ldb.search(expression="(|(&(revision=x)(dnsHostName=x))(!(&(description=x)(nextRid=y)))(badPwdCount=y))", attrs=["dnsHostName", "lastLogon"])
- self.assertEquals(len(res), 7)
+ self.assertEqual(len(res), 7)
res = sorted(res, key=attrgetter('dn'))
- self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
+ self.assertEqual(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue("dnsHostName" not in res[0])
- self.assertEquals(str(res[0]["lastLogon"]), "x")
- self.assertEquals(str(res[1].dn), self.samba4.dn("cn=B"))
+ self.assertEqual(str(res[0]["lastLogon"]), "x")
+ self.assertEqual(str(res[1].dn), self.samba4.dn("cn=B"))
self.assertTrue("dnsHostName" not in res[1])
- self.assertEquals(str(res[1]["lastLogon"]), "y")
- self.assertEquals(str(res[2].dn), self.samba4.dn("cn=C"))
+ self.assertEqual(str(res[1]["lastLogon"]), "y")
+ self.assertEqual(str(res[2].dn), self.samba4.dn("cn=C"))
self.assertTrue("dnsHostName" not in res[2])
- self.assertEquals(str(res[2]["lastLogon"]), "z")
- self.assertEquals(str(res[3].dn), self.samba4.dn("cn=X"))
- self.assertEquals(str(res[3]["dnsHostName"]), "x")
- self.assertEquals(str(res[3]["lastLogon"]), "x")
- self.assertEquals(str(res[4].dn), self.samba4.dn("cn=Z"))
- self.assertEquals(str(res[4]["dnsHostName"]), "z")
- self.assertEquals(str(res[4]["lastLogon"]), "z")
+ self.assertEqual(str(res[2]["lastLogon"]), "z")
+ self.assertEqual(str(res[3].dn), self.samba4.dn("cn=X"))
+ self.assertEqual(str(res[3]["dnsHostName"]), "x")
+ self.assertEqual(str(res[3]["lastLogon"]), "x")
+ self.assertEqual(str(res[4].dn), self.samba4.dn("cn=Z"))
+ self.assertEqual(str(res[4]["dnsHostName"]), "z")
+ self.assertEqual(str(res[4]["lastLogon"]), "z")
# Clean up
dns = [self.samba4.dn("cn=%s" % n) for n in ["A", "B", "C", "X", "Y", "Z"]]
# Check it's there
attrs = ["foo", "revision", "description"]
res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(str(res[0]["foo"]), "bar")
- self.assertEquals(str(res[0]["revision"]), "1")
- self.assertEquals(str(res[0]["description"]), "test")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
+ self.assertEqual(str(res[0]["foo"]), "bar")
+ self.assertEqual(str(res[0]["revision"]), "1")
+ self.assertEqual(str(res[0]["description"]), "test")
# Check it's not in the local db
res = self.samba4.db.search(expression="(cn=test)",
scope=SCOPE_DEFAULT, attrs=attrs)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# Check it's not in the remote db
res = self.samba3.db.search(expression="(cn=test)",
scope=SCOPE_DEFAULT, attrs=attrs)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# Modify local record
ldif = """
self.ldb.modify_ldif(ldif)
# Check in local db
res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(str(res[0]["foo"]), "baz")
- self.assertEquals(str(res[0]["revision"]), "1")
- self.assertEquals(str(res[0]["description"]), "foo")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
+ self.assertEqual(str(res[0]["foo"]), "baz")
+ self.assertEqual(str(res[0]["revision"]), "1")
+ self.assertEqual(str(res[0]["description"]), "foo")
# Rename local record
dn2 = "cn=toast,dc=idealx,dc=org"
self.ldb.rename(dn, dn2)
# Check in local db
res = self.ldb.search(dn2, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn2)
- self.assertEquals(str(res[0]["foo"]), "baz")
- self.assertEquals(str(res[0]["revision"]), "1")
- self.assertEquals(str(res[0]["description"]), "foo")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn2)
+ self.assertEqual(str(res[0]["foo"]), "baz")
+ self.assertEqual(str(res[0]["revision"]), "1")
+ self.assertEqual(str(res[0]["description"]), "foo")
# Delete local record
self.ldb.delete(dn2)
# Check it's gone
res = self.ldb.search(dn2, scope=SCOPE_BASE)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
def test_map_modify_remote_remote(self):
"""Modification of remote data of remote records"""
# Check it's there
res = self.samba3.db.search(dn2, scope=SCOPE_BASE,
attrs=["description", "sambaBadPasswordCount", "sambaNextRid"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn2)
- self.assertEquals(str(res[0]["description"]), "foo")
- self.assertEquals(str(res[0]["sambaBadPasswordCount"]), "3")
- self.assertEquals(str(res[0]["sambaNextRid"]), "1001")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn2)
+ self.assertEqual(str(res[0]["description"]), "foo")
+ self.assertEqual(str(res[0]["sambaBadPasswordCount"]), "3")
+ self.assertEqual(str(res[0]["sambaNextRid"]), "1001")
# Check in mapped db
attrs = ["description", "badPwdCount", "nextRid"]
res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs, expression="")
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(str(res[0]["description"]), "foo")
- self.assertEquals(str(res[0]["badPwdCount"]), "3")
- self.assertEquals(str(res[0]["nextRid"]), "1001")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
+ self.assertEqual(str(res[0]["description"]), "foo")
+ self.assertEqual(str(res[0]["badPwdCount"]), "3")
+ self.assertEqual(str(res[0]["nextRid"]), "1001")
# Check in local db
res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# Modify remote data of remote record
ldif = """
# Check in mapped db
res = self.ldb.search(dn, scope=SCOPE_BASE,
attrs=["description", "badPwdCount", "nextRid"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(str(res[0]["description"]), "test")
- self.assertEquals(str(res[0]["badPwdCount"]), "4")
- self.assertEquals(str(res[0]["nextRid"]), "1001")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
+ self.assertEqual(str(res[0]["description"]), "test")
+ self.assertEqual(str(res[0]["badPwdCount"]), "4")
+ self.assertEqual(str(res[0]["nextRid"]), "1001")
# Check in remote db
res = self.samba3.db.search(dn2, scope=SCOPE_BASE,
attrs=["description", "sambaBadPasswordCount", "sambaNextRid"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn2)
- self.assertEquals(str(res[0]["description"]), "test")
- self.assertEquals(str(res[0]["sambaBadPasswordCount"]), "4")
- self.assertEquals(str(res[0]["sambaNextRid"]), "1001")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn2)
+ self.assertEqual(str(res[0]["description"]), "test")
+ self.assertEqual(str(res[0]["sambaBadPasswordCount"]), "4")
+ self.assertEqual(str(res[0]["sambaNextRid"]), "1001")
# Rename remote record
dn2 = self.samba4.dn("cn=toast")
dn = dn2
res = self.ldb.search(dn, scope=SCOPE_BASE,
attrs=["description", "badPwdCount", "nextRid"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(str(res[0]["description"]), "test")
- self.assertEquals(str(res[0]["badPwdCount"]), "4")
- self.assertEquals(str(res[0]["nextRid"]), "1001")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
+ self.assertEqual(str(res[0]["description"]), "test")
+ self.assertEqual(str(res[0]["badPwdCount"]), "4")
+ self.assertEqual(str(res[0]["nextRid"]), "1001")
# Check in remote db
dn2 = self.samba3.dn("cn=toast")
res = self.samba3.db.search(dn2, scope=SCOPE_BASE,
attrs=["description", "sambaBadPasswordCount", "sambaNextRid"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn2)
- self.assertEquals(str(res[0]["description"]), "test")
- self.assertEquals(str(res[0]["sambaBadPasswordCount"]), "4")
- self.assertEquals(str(res[0]["sambaNextRid"]), "1001")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn2)
+ self.assertEqual(str(res[0]["description"]), "test")
+ self.assertEqual(str(res[0]["sambaBadPasswordCount"]), "4")
+ self.assertEqual(str(res[0]["sambaNextRid"]), "1001")
# Delete remote record
self.ldb.delete(dn)
# Check in mapped db that it's removed
res = self.ldb.search(dn, scope=SCOPE_BASE)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# Check in remote db
res = self.samba3.db.search(dn2, scope=SCOPE_BASE)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
def test_map_modify_remote_local(self):
"""Modification of local data of remote records"""
# Check in mapped db
attrs = ["revision", "description"]
res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(str(res[0]["description"]), "test")
- self.assertEquals(str(res[0]["revision"]), "1")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
+ self.assertEqual(str(res[0]["description"]), "test")
+ self.assertEqual(str(res[0]["revision"]), "1")
# Check in remote db
res = self.samba3.db.search(dn2, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn2)
- self.assertEquals(str(res[0]["description"]), "test")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn2)
+ self.assertEqual(str(res[0]["description"]), "test")
self.assertTrue("revision" not in res[0])
# Check in local db
res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
self.assertTrue("description" not in res[0])
- self.assertEquals(str(res[0]["revision"]), "1")
+ self.assertEqual(str(res[0]["revision"]), "1")
# Delete (newly) split record
self.ldb.delete(dn)
# Check it's there
attrs = ["description", "badPwdCount", "nextRid", "revision"]
res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(str(res[0]["description"]), "foo")
- self.assertEquals(str(res[0]["badPwdCount"]), "3")
- self.assertEquals(str(res[0]["nextRid"]), "1001")
- self.assertEquals(str(res[0]["revision"]), "1")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
+ self.assertEqual(str(res[0]["description"]), "foo")
+ self.assertEqual(str(res[0]["badPwdCount"]), "3")
+ self.assertEqual(str(res[0]["nextRid"]), "1001")
+ self.assertEqual(str(res[0]["revision"]), "1")
# Check in local db
res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
self.assertTrue("description" not in res[0])
self.assertTrue("badPwdCount" not in res[0])
self.assertTrue("nextRid" not in res[0])
- self.assertEquals(str(res[0]["revision"]), "1")
+ self.assertEqual(str(res[0]["revision"]), "1")
# Check in remote db
attrs = ["description", "sambaBadPasswordCount", "sambaNextRid",
"revision"]
res = self.samba3.db.search(dn2, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn2)
- self.assertEquals(str(res[0]["description"]), "foo")
- self.assertEquals(str(res[0]["sambaBadPasswordCount"]), "3")
- self.assertEquals(str(res[0]["sambaNextRid"]), "1001")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn2)
+ self.assertEqual(str(res[0]["description"]), "foo")
+ self.assertEqual(str(res[0]["sambaBadPasswordCount"]), "3")
+ self.assertEqual(str(res[0]["sambaNextRid"]), "1001")
self.assertTrue("revision" not in res[0])
# Modify of split record
# Check in mapped db
attrs = ["description", "badPwdCount", "nextRid", "revision"]
res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(str(res[0]["description"]), "test")
- self.assertEquals(str(res[0]["badPwdCount"]), "4")
- self.assertEquals(str(res[0]["nextRid"]), "1001")
- self.assertEquals(str(res[0]["revision"]), "2")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
+ self.assertEqual(str(res[0]["description"]), "test")
+ self.assertEqual(str(res[0]["badPwdCount"]), "4")
+ self.assertEqual(str(res[0]["nextRid"]), "1001")
+ self.assertEqual(str(res[0]["revision"]), "2")
# Check in local db
res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
self.assertTrue("description" not in res[0])
self.assertTrue("badPwdCount" not in res[0])
self.assertTrue("nextRid" not in res[0])
- self.assertEquals(str(res[0]["revision"]), "2")
+ self.assertEqual(str(res[0]["revision"]), "2")
# Check in remote db
attrs = ["description", "sambaBadPasswordCount", "sambaNextRid",
"revision"]
res = self.samba3.db.search(dn2, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn2)
- self.assertEquals(str(res[0]["description"]), "test")
- self.assertEquals(str(res[0]["sambaBadPasswordCount"]), "4")
- self.assertEquals(str(res[0]["sambaNextRid"]), "1001")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn2)
+ self.assertEqual(str(res[0]["description"]), "test")
+ self.assertEqual(str(res[0]["sambaBadPasswordCount"]), "4")
+ self.assertEqual(str(res[0]["sambaNextRid"]), "1001")
self.assertTrue("revision" not in res[0])
# Rename split record
dn = dn2
attrs = ["description", "badPwdCount", "nextRid", "revision"]
res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
- self.assertEquals(str(res[0]["description"]), "test")
- self.assertEquals(str(res[0]["badPwdCount"]), "4")
- self.assertEquals(str(res[0]["nextRid"]), "1001")
- self.assertEquals(str(res[0]["revision"]), "2")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
+ self.assertEqual(str(res[0]["description"]), "test")
+ self.assertEqual(str(res[0]["badPwdCount"]), "4")
+ self.assertEqual(str(res[0]["nextRid"]), "1001")
+ self.assertEqual(str(res[0]["revision"]), "2")
# Check in local db
res = self.samba4.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn)
self.assertTrue("description" not in res[0])
self.assertTrue("badPwdCount" not in res[0])
self.assertTrue("nextRid" not in res[0])
- self.assertEquals(str(res[0]["revision"]), "2")
+ self.assertEqual(str(res[0]["revision"]), "2")
# Check in remote db
dn2 = self.samba3.dn("cn=toast")
res = self.samba3.db.search(dn2, scope=SCOPE_BASE,
attrs=["description", "sambaBadPasswordCount", "sambaNextRid",
"revision"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0].dn), dn2)
- self.assertEquals(str(res[0]["description"]), "test")
- self.assertEquals(str(res[0]["sambaBadPasswordCount"]), "4")
- self.assertEquals(str(res[0]["sambaNextRid"]), "1001")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0].dn), dn2)
+ self.assertEqual(str(res[0]["description"]), "test")
+ self.assertEqual(str(res[0]["sambaBadPasswordCount"]), "4")
+ self.assertEqual(str(res[0]["sambaNextRid"]), "1001")
self.assertTrue("revision" not in res[0])
# Delete split record
self.ldb.delete(dn)
# Check in mapped db
res = self.ldb.search(dn, scope=SCOPE_BASE)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# Check in local db
res = self.samba4.db.search(dn, scope=SCOPE_BASE)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# Check in remote db
res = self.samba3.db.search(dn2, scope=SCOPE_BASE)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
expectedsamaccountname = computer["name"]
if not computer["name"].endswith('$'):
expectedsamaccountname = "%s$" % computer["name"]
- self.assertEquals("%s" % found.get("name"), expectedname)
- self.assertEquals("%s" % found.get("sAMAccountName"),
+ self.assertEqual("%s" % found.get("name"), expectedname)
+ self.assertEqual("%s" % found.get("sAMAccountName"),
expectedsamaccountname)
- self.assertEquals("%s" % found.get("description"),
+ self.assertEqual("%s" % found.get("description"),
computer["description"])
def tearDown(self):
"--description=%s" % computer["description"])
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
self.assertIn("Computer '%s' created successfully" %
computer["name"], out)
expectedsamaccountname = computer["name"]
if not computer["name"].endswith('$'):
expectedsamaccountname = "%s$" % computer["name"]
- self.assertEquals("%s" % found.get("name"), expectedname)
- self.assertEquals("%s" % found.get("sAMAccountName"),
+ self.assertEqual("%s" % found.get("name"), expectedname)
+ self.assertEqual("%s" % found.get("sAMAccountName"),
expectedsamaccountname)
- self.assertEquals("%s" % found.get("description"),
+ self.assertEqual("%s" % found.get("description"),
computer["description"])
def test_list(self):
self.assertCmdSuccess(result, out, err,
"Failed to move computer '%s'" %
computer["name"])
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
self.assertIn('Moved computer "%s"' % computer["name"], out)
found = self._find_computer(computer["name"])
"CN=%s,OU=%s,%s" %
(computername, parentou["name"],
self.samdb.domain_dn()))
- self.assertEquals(found.get("dn"), newexpecteddn,
+ self.assertEqual(found.get("dn"), newexpecteddn,
"Moved computer '%s' does not exist" %
computer["name"])
self.assertIsNotNone(found)
contactname = contact["expectedname"]
- self.assertEquals("%s" % found.get("name"), contactname)
- self.assertEquals("%s" % found.get("description"),
+ self.assertEqual("%s" % found.get("name"), contactname)
+ self.assertEqual("%s" % found.get("description"),
contact["description"])
def tearDown(self):
(result, out, err) = self._create_contact(contact, ou="OU=testOU")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
self.assertIn("Contact '%s' created successfully" %
contact["expectedname"], out)
found = self._find_contact(contact["expectedname"])
contactname = contact["expectedname"]
- self.assertEquals("%s" % found.get("name"), contactname)
- self.assertEquals("%s" % found.get("description"),
+ self.assertEqual("%s" % found.get("name"), contactname)
+ self.assertEqual("%s" % found.get("description"),
contact["description"])
# try to delete all the contacts we just created, by DN
(result, out, err) = self._create_contact(contact)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
self.assertIn("Contact '%s' created successfully" %
contact["expectedname"], out)
found = self._find_contact(contact["expectedname"])
contactname = contact["expectedname"]
- self.assertEquals("%s" % found.get("name"), contactname)
- self.assertEquals("%s" % found.get("description"),
+ self.assertEqual("%s" % found.get("name"), contactname)
+ self.assertEqual("%s" % found.get("description"),
contact["description"])
def test_list(self):
self.assertCmdSuccess(result, out, err,
"Failed to move contact '%s'" %
contact["expectedname"])
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
self.assertIn('Moved contact "%s"' % contact["expectedname"], out)
found = self._find_contact(contact["expectedname"])
(contactname,
parentou["name"],
self.samdb.domain_dn()))
- self.assertEquals(found.get("dn"), newexpecteddn,
+ self.assertEqual(found.get("dn"), newexpecteddn,
"Moved contact '%s' does not exist" %
contact["expectedname"])
# 8Gb is used
def test_default(self):
(result, out, err) = self.clone()
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(8 * 1024 * 1024 * 1024)
def test_64Mb(self):
(result, out, err) = self.clone("64Mb")
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(64 * 1024 * 1024)
def test_no_unit_suffix(self):
"""Tests if a sddl string can be added 'the normal way'"""
(result, out, err) = self.runsubcmd("dsacl", "set","--objectdn=%s" % self.dn, "--sddl=%s" % self.sddl)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
#extract only the two sddl strings from samba-tool output
acl_list=re.findall('.*descriptor for.*:\n(.*?)\n',out)
self.assertNotEqual(acl_list[0], acl_list[1], "new and old SDDL string differ")
(result, out, err) = self.runsubcmd("dsacl", "get",
"--objectdn=%s" % self.dn)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
#extract only the two sddl strings from samba-tool output
acl_list_get=re.findall('^descriptor for.*:\n(.*?)\n', out)
"--objectdn=%s" % self.dn,
"--sddl=%s" % self.sddl)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
#extract only the two sddl strings from samba-tool output
acl_list_old=re.findall('old descriptor for.*:\n(.*?)\n', out)
self.assertEqual(acl_list_old, acl_list_get,
(result, out, err) = self.runsubcmd("dsacl", "get",
"--objectdn=%s" % self.dn)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
#extract only the two sddl strings from samba-tool output
acl_list_get2=re.findall('^descriptor for.*:\n(.*?)\n', out)
self.assertEqual(acl_list, acl_list_get2,
"""Tests if we can add multiple, different sddl strings at the same time"""
(result, out, err) = self.runsubcmd("dsacl", "set","--objectdn=%s" % self.dn, "--sddl=%s" % self.sddl_multi)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
#extract only the two sddl strings from samba-tool output
acl_list=re.findall('.*descriptor for.*:\n(.*?)\n',out)
for ace in re.findall('\(.*?\)',self.sddl_multi):
def test_duplicatesddl(self):
"""Tests if an already existing sddl string can be added causing duplicate entry"""
acl_list = self._double_sddl_check(self.sddl,self.sddl)
- self.assertEquals(acl_list[0],acl_list[1])
+ self.assertEqual(acl_list[0],acl_list[1])
def test_casesensitivesddl(self):
"""Tests if an already existing sddl string can be added in different cases causing duplicate entry"""
acl_list = self._double_sddl_check(self.sddl_lc,self.sddl_uc)
- self.assertEquals(acl_list[0],acl_list[1])
+ self.assertEqual(acl_list[0],acl_list[1])
def test_sidsddl(self):
"""Tests if an already existing sddl string can be added with SID instead of SDDL SIDString causing duplicate entry"""
acl_list = self._double_sddl_check(self.sddl,self.sddl_sid)
- self.assertEquals(acl_list[0],acl_list[1])
+ self.assertEqual(acl_list[0],acl_list[1])
def test_twosddl(self):
"""Tests if an already existing sddl string can be added by using it twice/in combination with non existing sddl string causing duplicate entry"""
acl_list = self._double_sddl_check(self.sddl,self.sddl + self.sddl)
- self.assertEquals(acl_list[0],acl_list[1])
+ self.assertEqual(acl_list[0],acl_list[1])
def _double_sddl_check(self,sddl1,sddl2):
"""Adds two sddl strings and checks if there was an ace change after the second adding"""
(result, out, err) = self.runsubcmd("dsacl", "set","--objectdn=%s" % self.dn, "--sddl=%s" % sddl1)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
acl_list = re.findall('.*descriptor for.*:\n(.*?)\n',out)
self.assertMatch(acl_list[1], sddl1, "new SDDL string should be contained within second sddl output - is not")
#add sddl2
(result, out, err) = self.runsubcmd("dsacl", "set","--objectdn=%s" % self.dn, "--sddl=%s" % sddl2)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
acl_list = re.findall('.*descriptor for.*:\n(.*?)\n',out)
return acl_list
os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("dsheuristics: <NO VALUE>", out)
def test_modify_dsheuristics(self):
os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("set dsheuristics: 0000002", out)
(result, out, err) = self.runsubcmd("fsmo", "show")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
# Check that the output is sensible
samdb = self.getSamDB("-H", "ldap://%s" % os.environ["SERVER"],
(result, out, err) = group["createGroupFn"](group)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
if 'unix' in group["name"]:
self.assertIn("Modified Group '%s' successfully"
self.assertIsNotNone(found)
- self.assertEquals("%s" % found.get("name"), group["name"])
- self.assertEquals("%s" % found.get("description"), group["description"])
+ self.assertEqual("%s" % found.get("name"), group["name"])
+ self.assertEqual("%s" % found.get("description"), group["description"])
def tearDown(self):
super(GroupCmdTestCase, self).tearDown()
os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
self.assertIn("Added group %s" % group["name"], out)
found = self._find_group(group["name"])
- self.assertEquals("%s" % found.get("samaccountname"),
+ self.assertEqual("%s" % found.get("samaccountname"),
"%s" % group["name"])
def test_list(self):
full_ou_dn = str(self.samdb.normalize_dn_in_domain("OU=movetest"))
(result, out, err) = self.runsubcmd("ou", "create", full_ou_dn)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
self.assertIn('Created ou "%s"' % full_ou_dn, out)
for group in self.groups:
"-U%s%%%s" % (os.environ["DC_USERNAME"],
os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("dn: CN=Domain Users,CN=Users,DC=addom,DC=samba,DC=example,DC=com", out)
def _randomGroup(self, base={}):
its template """
found = self._find_group(group["name"])
- self.assertEquals("%s" % found.get("name"), group["name"])
- self.assertEquals("%s" % found.get("description"), group["description"])
+ self.assertEqual("%s" % found.get("name"), group["name"])
+ self.assertEqual("%s" % found.get("description"), group["description"])
def _check_posix_group(self, group):
""" check if a posix_group from SamDB has the same attributes as
its template """
found = self._find_group(group["name"])
- self.assertEquals("%s" % found.get("gidNumber"), "%s" %
+ self.assertEqual("%s" % found.get("gidNumber"), "%s" %
group["gidNumber"])
self._check_group(group)
template """
found = self._find_group(group["name"])
- self.assertEquals("%s" % found.get("gidNumber"), "%s" %
+ self.assertEqual("%s" % found.get("gidNumber"), "%s" %
group["gidNumber"])
self._check_group(group)
# 8Gb is used
def test_join_as_dc_default(self):
(result, out, err) = self.join(role="DC")
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(8 * 1024 * 1024 * 1024)
self.assertFalse(self.is_rodc())
# Join as an DC with the lmdb backend size set to 1Gb
def test_join_as_dc(self):
(result, out, err) = self.join("1Gb", "DC")
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(1 * 1024 * 1024 * 1024)
self.assertFalse(self.is_rodc())
# Join as an RODC with the lmdb backend size set to 128Mb
def test_join_as_rodc(self):
(result, out, err) = self.join("128Mb", "RODC")
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(128 * 1024 * 1024)
self.assertTrue(self.is_rodc())
# Join as an RODC with --backend-store-size
def test_join_as_rodc_default(self):
(result, out, err) = self.join(role="RODC")
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(8 * 1024 * 1024 * 1024)
self.assertTrue(self.is_rodc())
(result, out, err) = self.runsubcmd("ntacl", "sysvolreset",
"--use-ntvfs")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(out, "", "Shouldn't be any output messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
self.assertIn("Please note that POSIX permissions have NOT been changed, only the stored NT ACL", err)
def test_s3fs(self):
"--use-s3fs")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
- self.assertEquals(out, "", "Shouldn't be any output messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
def test_ntvfs_check(self):
(result, out, err) = self.runsubcmd("ntacl", "sysvolreset",
"--use-ntvfs")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(out, "", "Shouldn't be any output messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
self.assertIn("Please note that POSIX permissions have NOT been changed, only the stored NT ACL", err)
# Now check they were set correctly
(result, out, err) = self.runsubcmd("ntacl", "sysvolcheck")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
- self.assertEquals(out, "", "Shouldn't be any output messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
def test_s3fs_check(self):
(result, out, err) = self.runsubcmd("ntacl", "sysvolreset",
"--use-s3fs")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
- self.assertEquals(out, "", "Shouldn't be any output messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
# Now check they were set correctly
(result, out, err) = self.runsubcmd("ntacl", "sysvolcheck")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
- self.assertEquals(out, "", "Shouldn't be any output messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
class NtACLCmdGetSetTestCase(SambaToolCmdTest):
(result, out, err) = self.runsubcmd("ntacl", "set", self.acl, tempf,
"--use-ntvfs")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(out, "", "Shouldn't be any output messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
self.assertIn("Please note that POSIX permissions have NOT been changed, only the stored NT ACL", err)
def test_s3fs(self):
"--use-s3fs")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
- self.assertEquals(out, "", "Shouldn't be any output messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
def test_ntvfs_check(self):
path = os.environ['SELFTEST_PREFIX']
(result, out, err) = self.runsubcmd("ntacl", "set", self.acl, tempf,
"--use-ntvfs")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(out, "", "Shouldn't be any output messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
self.assertIn("Please note that POSIX permissions have NOT been changed, only the stored NT ACL", err)
# Now check they were set correctly
(result, out, err) = self.runsubcmd("ntacl", "get", tempf,
"--use-ntvfs", "--as-sddl")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
- self.assertEquals(self.acl + "\n", out, "Output should be the ACL")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
+ self.assertEqual(self.acl + "\n", out, "Output should be the ACL")
def test_s3fs_check(self):
path = os.environ['SELFTEST_PREFIX']
(result, out, err) = self.runsubcmd("ntacl", "set", self.acl, tempf,
"--use-s3fs")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(out, "", "Shouldn't be any output messages")
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
# Now check they were set correctly
(result, out, err) = self.runsubcmd("ntacl", "get", tempf,
"--use-s3fs", "--as-sddl")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
- self.assertEquals(self.acl + "\n", out, "Output should be the ACL")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
+ self.assertEqual(self.acl + "\n", out, "Output should be the ACL")
class NtACLCmdChangedomsidTestCase(SambaToolCmdTest):
"""Tests for samba-tool ntacl changedomsid subcommand"""
tempf,
"--use-ntvfs")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(out, "", "Shouldn't be any output messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
self.assertIn("Please note that POSIX permissions have NOT been "
"changed, only the stored NT ACL", err)
tempf,
"--use-ntvfs")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(out, "", "Shouldn't be any output messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
self.assertIn("Please note that POSIX permissions have NOT been "
"changed, only the stored NT ACL.", err)
"--use-ntvfs",
"--as-sddl")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
- self.assertEquals(self.new_acl + "\n", out, "Output should be the ACL")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
+ self.assertEqual(self.new_acl + "\n", out, "Output should be the ACL")
def test_s3fs_check(self):
path = os.environ['SELFTEST_PREFIX']
"--use-s3fs",
"--service=sysvol")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(out, "", "Shouldn't be any output messages")
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
(result, out, err) = self.runsubcmd("ntacl",
"changedomsid",
"--use-s3fs",
"--service=sysvol")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(out, "", "Shouldn't be any output messages")
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(out, "", "Shouldn't be any output messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
# Now check they were set correctly
(result, out, err) = self.runsubcmd("ntacl",
"--as-sddl",
"--service=sysvol")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
- self.assertEquals(self.new_acl + "\n", out, "Output should be the ACL")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
+ self.assertEqual(self.new_acl + "\n", out, "Output should be the ACL")
(result, out, err) = self._create_ou(ou)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
full_ou_dn = self.samdb.normalize_dn_in_domain("OU=%s" % ou["name"])
self.assertIn('Created ou "%s"' % full_ou_dn, out)
self.assertIsNotNone(found)
- self.assertEquals("%s" % found.get("name"), ou["name"])
- self.assertEquals("%s" % found.get("description"),
+ self.assertEqual("%s" % found.get("name"), ou["name"])
+ self.assertEqual("%s" % found.get("description"),
ou["description"])
def tearDown(self):
"--description=%s" % ou["description"])
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
full_ou_dn = self.samdb.normalize_dn_in_domain("OU=%s" % ou["name"])
self.assertIn('Created ou "%s"' % full_ou_dn, out)
found = self._find_ou(ou["name"])
- self.assertEquals("%s" % found.get("ou"),
+ self.assertEqual("%s" % found.get("ou"),
"%s" % ou["name"])
# try to delete all the ous we just created (with full dn)
"--description=%s" % ou["description"])
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
full_ou_dn = self.samdb.normalize_dn_in_domain("OU=%s" % ou["name"])
self.assertIn('Created ou "%s"' % full_ou_dn, out)
found = self._find_ou(ou["name"])
- self.assertEquals("%s" % found.get("ou"),
+ self.assertEqual("%s" % found.get("ou"),
"%s" % ou["name"])
def test_list(self):
"OU=%s" % parentou["name"])
self.assertCmdSuccess(result, out, err,
"Failed to move ou '%s'" % ou["name"])
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
full_ou_dn = self.samdb.normalize_dn_in_domain("OU=%s" % ou["name"])
self.assertIn('Moved ou "%s"' % full_ou_dn, out)
"OU=%s,OU=%s,%s" %
(ou["name"], parentou["name"],
self.samdb.domain_dn()))
- self.assertEquals(found.get("dn"), newexpecteddn,
+ self.assertEqual(found.get("dn"), newexpecteddn,
"Moved ou '%s' does not exist" %
ou["name"])
"--full-dn")
self.assertCmdSuccess(result, out, err,
"Failed to list ou's objects")
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
objlist = self.samdb.search(base=self.samdb.domain_dn(),
scope=ldb.SCOPE_ONELEVEL,
"--full-dn")
self.assertCmdSuccess(result, out, err,
"Failed to list ous")
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
filter = "(objectClass=organizationalUnit)"
objlist = self.samdb.search(base=self.samdb.domain_dn(),
'msDS-LockoutObservationWindow',
'msDS-LockoutThreshold', 'msDS-LockoutDuration']
res = self.ldb.search(dn, scope=ldb.SCOPE_BASE, attrs=pso_attrs)
- self.assertEquals(len(res), 1, "PSO lookup failed")
+ self.assertEqual(len(res), 1, "PSO lookup failed")
# convert types in the PSO-settings to what the search returns, i.e.
# boolean --> string, seconds --> timestamps in -100 nanosecond units
max_age = -int(pso.password_age_max * (1e7))
# check the PSO's settings match the search results
- self.assertEquals(str(res[0]['msDS-PasswordComplexityEnabled'][0]),
+ self.assertEqual(str(res[0]['msDS-PasswordComplexityEnabled'][0]),
complexity_str)
plaintext_res = res[0]['msDS-PasswordReversibleEncryptionEnabled'][0]
- self.assertEquals(str(plaintext_res), plaintext_str)
- self.assertEquals(int(res[0]['msDS-PasswordHistoryLength'][0]),
+ self.assertEqual(str(plaintext_res), plaintext_str)
+ self.assertEqual(int(res[0]['msDS-PasswordHistoryLength'][0]),
pso.history_len)
- self.assertEquals(int(res[0]['msDS-MinimumPasswordLength'][0]),
+ self.assertEqual(int(res[0]['msDS-MinimumPasswordLength'][0]),
pso.password_len)
- self.assertEquals(int(res[0]['msDS-MinimumPasswordAge'][0]), min_age)
- self.assertEquals(int(res[0]['msDS-MaximumPasswordAge'][0]), max_age)
- self.assertEquals(int(res[0]['msDS-LockoutObservationWindow'][0]),
+ self.assertEqual(int(res[0]['msDS-MinimumPasswordAge'][0]), min_age)
+ self.assertEqual(int(res[0]['msDS-MaximumPasswordAge'][0]), max_age)
+ self.assertEqual(int(res[0]['msDS-LockoutObservationWindow'][0]),
lockout_window)
- self.assertEquals(int(res[0]['msDS-LockoutDuration'][0]),
+ self.assertEqual(int(res[0]['msDS-LockoutDuration'][0]),
lockout_duration)
- self.assertEquals(int(res[0]['msDS-LockoutThreshold'][0]),
+ self.assertEqual(int(res[0]['msDS-LockoutThreshold'][0]),
pso.lockout_attempts)
- self.assertEquals(int(res[0]['msDS-PasswordSettingsPrecedence'][0]),
+ self.assertEqual(int(res[0]['msDS-PasswordSettingsPrecedence'][0]),
pso.precedence)
# check we can also display the PSO via the show command
self.obj_cleanup.append("CN=%s,%s" % (pso_name, self.pso_container))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("successfully created", out)
self.check_pso(pso_name, expected_pso)
self.user_auth)
self.obj_cleanup.append("CN=%s,%s" % (pso_name, self.pso_container))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("successfully created", out)
self.check_pso(pso_name, expected_pso)
# sanity-check the cmd was successful
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("successfully created", out)
self.check_pso(pso_name, pso_settings)
"-H", self.server,
self.user_auth)
self.assertCmdSuccess(res, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("Successfully updated", out)
# check the PSO's settings now reflect the new values
"-H", self.server,
self.user_auth)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("Deleted PSO", out)
dn = "CN=%s,%s" % (pso_name, self.pso_container)
self.obj_cleanup.remove(dn)
self.fail("PSO shouldn't exist")
except ldb.LdbError as e:
(enum, estr) = e.args
- self.assertEquals(enum, ldb.ERR_NO_SUCH_OBJECT)
+ self.assertEqual(enum, ldb.ERR_NO_SUCH_OBJECT)
# run the same cmd again - it should fail because PSO no longer exists
(result, out, err) = self.runsublevelcmd("domain", ("passwordsettings",
user.name, "-H", self.server,
self.user_auth)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
if pso is None:
self.assertIn("No PSO applies to user", out)
else:
# then check the DB tells us the same thing
if pso is None:
- self.assertEquals(user.get_resultant_PSO(), None)
+ self.assertEqual(user.get_resultant_PSO(), None)
else:
- self.assertEquals(user.get_resultant_PSO(), pso.dn)
+ self.assertEqual(user.get_resultant_PSO(), pso.dn)
def test_pso_apply_to_user(self):
"""Checks we can apply/unapply a PSO to a user"""
group_name, "-H", self.server,
self.user_auth)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.check_pso_applied(user, pso=test_pso)
# we should fail if we try to apply the same PSO/group twice though
user.name, "-H", self.server,
self.user_auth)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.check_pso_applied(user, pso=test_pso)
# check samba-tool can successfully unlink a group from a PSO
group_name, "-H", self.server,
self.user_auth)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
# PSO still applies directly to the user, even though group was removed
self.check_pso_applied(user, pso=test_pso)
user.name, "-H", self.server,
self.user_auth)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.check_pso_applied(user, pso=None)
def test_pso_unpriv(self):
"show"), "-H", self.server,
self.user_auth)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
# check an arbitrary setting is displayed correctly
min_pwd_len = self.ldb.get_minPwdLength()
"-H", self.server,
self.user_auth)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("successful", out)
- self.assertEquals(new_len, self.ldb.get_minPwdLength())
+ self.assertEqual(new_len, self.ldb.get_minPwdLength())
# check the updated value is now displayed
(result, out, err) = self.runsublevelcmd("domain", ("passwordsettings",
"show"), "-H", self.server,
self.user_auth)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("Minimum password length: %u" % new_len, out)
def test_domain_passwordsettings_pwdage(self):
"-H", self.server,
self.user_auth)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("successful", out)
self.assertNotEquals(max_pwd_age, self.ldb.get_maxPwdAge())
"-H", self.server,
self.user_auth)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("successful", out)
self.assertNotEquals(min_pwd_age, self.ldb.get_minPwdAge())
# 8Gb is used
def test_promote_dc_default(self):
(result, out, err) = self.join_member()
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
(result, out, err) = self.promote(role="DC")
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(8 * 1024 * 1024 * 1024)
self.assertFalse(self.is_rodc())
# 8Gb is used
def test_promote_rodc_default(self):
(result, out, err) = self.join_member()
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
(result, out, err) = self.promote(role="RODC")
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(8 * 1024 * 1024 * 1024)
self.assertTrue(self.is_rodc())
# Promote to a DC with a backend size of 96Mb
def test_promote_dc_96Mb(self):
(result, out, err) = self.join_member()
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
(result, out, err) = self.promote(role="DC", size="96Mb")
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(96 * 1024 * 1024)
self.assertFalse(self.is_rodc())
# Promote to an RODC with a backend size of 256Mb
def test_promote_rodc_256Mb(self):
(result, out, err) = self.join_member()
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
(result, out, err) = self.promote(role="RODC", size="256Mb")
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(256 * 1024 * 1024)
self.assertTrue(self.is_rodc())
# 8Gb is used
def test_default(self):
(result, out, err) = self.provision()
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(8 * 1024 * 1024 * 1024)
def test_64Mb(self):
(result, out, err) = self.provision("64Mb")
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(64 * 1024 * 1024)
def test_1Gb(self):
(result, out, err) = self.provision("1Gb")
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(1 * 1024 * 1024 * 1024)
# 128Mb specified in bytes.
#
def test_134217728b(self):
(result, out, err) = self.provision("134217728b")
- self.assertEquals(0, result)
+ self.assertEqual(0, result)
self.check_lmdb_environment_sizes(134217728)
def test_no_unit_suffix(self):
os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("dn: CN=uid,CN=Schema,CN=Configuration,", out)
def test_modify_attribute_searchflags(self):
os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("modified cn=uid,CN=Schema,CN=Configuration,", out)
(result, out, err) = self.runsublevelcmd("schema", ("attribute",
os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("modified cn=uid,CN=Schema,CN=Configuration,", out)
(result, out, err) = self.runsublevelcmd("schema", ("attribute",
os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("modified cn=uid,CN=Schema,CN=Configuration,", out)
def test_show_oc_attribute(self):
os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("--- MAY contain ---", out)
self.assertIn("--- MUST contain ---", out)
os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("dn: CN=Person,CN=Schema,CN=Configuration,", out)
ret = self.samdb.search(base=dnsites, scope=ldb.SCOPE_ONELEVEL,
expression='(cn=%s)' % sitename)
- self.assertEquals(len(ret), 1)
+ self.assertEqual(len(ret), 1)
# now delete it
self.samdb.delete(dnsite, ["tree_delete:0"])
def test_timefail(self):
"""Run time against a non-existent server, and make sure it fails"""
(result, out, err) = self.runcmd("time", "notaserver")
- self.assertEquals(result, -1, "check for result code")
+ self.assertEqual(result, -1, "check for result code")
self.assertNotEqual(err.strip().find("NT_STATUS_OBJECT_NAME_NOT_FOUND"), -1, "ensure right error string")
- self.assertEquals(out, "", "ensure no output returned")
+ self.assertEqual(out, "", "ensure no output returned")
(result, out, err) = user["createUserFn"](user)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
if 'unix' in user["name"]:
self.assertIn("Modified User '%s' successfully" % user["name"],
out)
"-U%s%%%s" % (os.environ["DC_USERNAME"], os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("User '%s' created successfully" % user["name"], out)
found = self._find_user(user["name"])
- self.assertEquals("%s" % found.get("cn"), "%(name)s" % user)
- self.assertEquals("%s" % found.get("name"), "%(name)s" % user)
+ self.assertEqual("%s" % found.get("cn"), "%(name)s" % user)
+ self.assertEqual("%s" % found.get("name"), "%(name)s" % user)
def _verify_supplementalCredentials(self, ldif,
min_packages=3,
"-H", "ldap://%s" % os.environ["DC_SERVER"],
"-U%s%%%s" % (os.environ["DC_USERNAME"], os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err, "Ensure setpassword runs")
- self.assertEquals(err, "", "setpassword with url")
+ self.assertEqual(err, "", "setpassword with url")
self.assertMatch(out, "Changed password OK", "setpassword with url")
attributes = "sAMAccountName,unicodePwd,supplementalCredentials,virtualClearTextUTF8,virtualClearTextUTF16,virtualSSHA,virtualSambaGPG"
user["name"],
"--newpassword=%s" % newpasswd)
self.assertCmdSuccess(result, out, err, "Ensure setpassword runs")
- self.assertEquals(err, "", "setpassword without url")
+ self.assertEqual(err, "", "setpassword without url")
self.assertMatch(out, "Changed password OK", "setpassword without url")
(result, out, err) = self.runsubcmd("user", "syncpasswords", "--no-wait")
"-H", "ldap://%s" % os.environ["DC_SERVER"],
"-U%s%%%s" % (os.environ["DC_USERNAME"], os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err, "Ensure setpassword runs")
- self.assertEquals(err, "", "setpassword with forced change")
+ self.assertEqual(err, "", "setpassword with forced change")
self.assertMatch(out, "Changed password OK", "setpassword with forced change")
def test_setexpiry(self):
full_ou_dn = str(self.samdb.normalize_dn_in_domain("OU=movetest"))
(result, out, err) = self.runsubcmd("ou", "create", full_ou_dn)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "There shouldn't be any error message")
+ self.assertEqual(err, "", "There shouldn't be any error message")
self.assertIn('Created ou "%s"' % full_ou_dn, out)
for user in self.users:
"-U%s%%%s" % (os.environ["DC_USERNAME"], os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("User '%s' created successfully" % user["name"], out)
self._check_posix_user(user)
"-U%s%%%s" % (os.environ["DC_USERNAME"], os.environ["DC_PASSWORD"]))
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
self.assertIn("User '%s' created successfully" % user["name"], out)
self._check_posix_user(user)
""" check if a user from SamDB has the same attributes as its template """
found = self._find_user(user["name"])
- self.assertEquals("%s" % found.get("name"), "%(given-name)s %(surname)s" % user)
- self.assertEquals("%s" % found.get("title"), user["job-title"])
- self.assertEquals("%s" % found.get("company"), user["company"])
- self.assertEquals("%s" % found.get("description"), user["description"])
- self.assertEquals("%s" % found.get("department"), user["department"])
+ self.assertEqual("%s" % found.get("name"), "%(given-name)s %(surname)s" % user)
+ self.assertEqual("%s" % found.get("title"), user["job-title"])
+ self.assertEqual("%s" % found.get("company"), user["company"])
+ self.assertEqual("%s" % found.get("description"), user["description"])
+ self.assertEqual("%s" % found.get("department"), user["department"])
def _check_posix_user(self, user):
""" check if a posix_user from SamDB has the same attributes as its template """
found = self._find_user(user["name"])
- self.assertEquals("%s" % found.get("loginShell"), user["loginShell"])
- self.assertEquals("%s" % found.get("gecos"), user["gecos"])
- self.assertEquals("%s" % found.get("uidNumber"), "%s" % user["uidNumber"])
- self.assertEquals("%s" % found.get("gidNumber"), "%s" % user["gidNumber"])
- self.assertEquals("%s" % found.get("uid"), user["uid"])
+ self.assertEqual("%s" % found.get("loginShell"), user["loginShell"])
+ self.assertEqual("%s" % found.get("gecos"), user["gecos"])
+ self.assertEqual("%s" % found.get("uidNumber"), "%s" % user["uidNumber"])
+ self.assertEqual("%s" % found.get("gidNumber"), "%s" % user["gidNumber"])
+ self.assertEqual("%s" % found.get("uid"), user["uid"])
self._check_user(user)
def _check_unix_user(self, user):
template """
found = self._find_user(user["name"])
- self.assertEquals("%s" % found.get("loginShell"), user["loginShell"])
- self.assertEquals("%s" % found.get("gecos"), user["gecos"])
- self.assertEquals("%s" % found.get("uidNumber"), "%s" %
+ self.assertEqual("%s" % found.get("loginShell"), user["loginShell"])
+ self.assertEqual("%s" % found.get("gecos"), user["gecos"])
+ self.assertEqual("%s" % found.get("uidNumber"), "%s" %
user["uidNumber"])
- self.assertEquals("%s" % found.get("gidNumber"), "%s" %
+ self.assertEqual("%s" % found.get("gidNumber"), "%s" %
user["gidNumber"])
- self.assertEquals("%s" % found.get("uid"), user["uid"])
+ self.assertEqual("%s" % found.get("uid"), user["uid"])
self._check_user(user)
def _create_user(self, user):
sha512 = _get_attribute(out, "virtualCryptSHA512")
out = self._get_password("virtualCryptSHA256,virtualCryptSHA512")
- self.assertEquals(sha256, _get_attribute(out, "virtualCryptSHA256"))
- self.assertEquals(sha512, _get_attribute(out, "virtualCryptSHA512"))
+ self.assertEqual(sha256, _get_attribute(out, "virtualCryptSHA256"))
+ self.assertEqual(sha512, _get_attribute(out, "virtualCryptSHA512"))
# gpg decryption not enabled.
# both virtual attributes specified, rounds specified
sha512 = _get_attribute(out, "virtualCryptSHA512")
out = self._get_password("virtualCryptSHA256,virtualCryptSHA512")
- self.assertEquals(sha256, _get_attribute(out, "virtualCryptSHA256"))
- self.assertEquals(sha512, _get_attribute(out, "virtualCryptSHA512"))
+ self.assertEqual(sha256, _get_attribute(out, "virtualCryptSHA256"))
+ self.assertEqual(sha512, _get_attribute(out, "virtualCryptSHA512"))
# gpg decryption not enabled.
# both virtual attributes specified, rounds specified
out = self._get_password("virtualCryptSHA256;rounds=2561," +
"virtualCryptSHA512;rounds=5129")
- self.assertEquals(sha256, _get_attribute(out, "virtualCryptSHA256"))
- self.assertEquals(sha512, _get_attribute(out, "virtualCryptSHA512"))
+ self.assertEqual(sha256, _get_attribute(out, "virtualCryptSHA256"))
+ self.assertEqual(sha512, _get_attribute(out, "virtualCryptSHA512"))
# Number of rounds should match that specified
self.assertTrue(sha256.startswith("{CRYPT}$5$rounds=2561"))
out = self._get_password("virtualCryptSHA256;rounds=4000," +
"virtualCryptSHA512;rounds=5000")
- self.assertEquals(sha256, _get_attribute(out, "virtualCryptSHA256"))
- self.assertEquals(sha512, _get_attribute(out, "virtualCryptSHA512"))
+ self.assertEqual(sha256, _get_attribute(out, "virtualCryptSHA256"))
+ self.assertEqual(sha512, _get_attribute(out, "virtualCryptSHA512"))
# As the number of rounds did not match, should have returned the
# first hash of the coresponding scheme
out = self._get_password("virtualCryptSHA256," +
"virtualCryptSHA512")
- self.assertEquals(sha256, _get_attribute(out, "virtualCryptSHA256"))
- self.assertEquals(sha512, _get_attribute(out, "virtualCryptSHA512"))
+ self.assertEqual(sha256, _get_attribute(out, "virtualCryptSHA256"))
+ self.assertEqual(sha512, _get_attribute(out, "virtualCryptSHA512"))
# gpg decryption enabled.
# both virtual attributes specified, no rounds option
sha512 = _get_attribute(out, "virtualCryptSHA512")
out = self._get_password("virtualCryptSHA256,virtualCryptSHA512", True)
- self.assertEquals(sha256, _get_attribute(out, "virtualCryptSHA256"))
- self.assertEquals(sha512, _get_attribute(out, "virtualCryptSHA512"))
+ self.assertEqual(sha256, _get_attribute(out, "virtualCryptSHA256"))
+ self.assertEqual(sha512, _get_attribute(out, "virtualCryptSHA512"))
# gpg decryption enabled.
# both virtual attributes specified, rounds specified
out = self._get_password("virtualCryptSHA256;rounds=2561," +
"virtualCryptSHA512;rounds=5129",
True)
- self.assertEquals(sha256, _get_attribute(out, "virtualCryptSHA256"))
- self.assertEquals(sha512, _get_attribute(out, "virtualCryptSHA512"))
+ self.assertEqual(sha256, _get_attribute(out, "virtualCryptSHA256"))
+ self.assertEqual(sha512, _get_attribute(out, "virtualCryptSHA512"))
# The returned hashes should specify the correct number of rounds
self.assertTrue(sha256.startswith("{CRYPT}$5$rounds=2561"))
self.assertCmdSuccess(result, out, err)
lines = out.splitlines()
- self.assertEquals(len(lines), 1)
+ self.assertEqual(len(lines), 1)
line = lines[0]
self.assertTrue(line.startswith('DOMAIN'))
try:
os.remove(self.tempdir + "/test.db")
except OSError as e:
- self.assertEquals(e.errno, errno.ENOENT)
+ self.assertEqual(e.errno, errno.ENOENT)
try:
os.remove(self.tempdir + "/existing.db")
except OSError as e:
- self.assertEquals(e.errno, errno.ENOENT)
+ self.assertEqual(e.errno, errno.ENOENT)
super(SamDBApiTestCase, self).tearDown()
self.fail("Exception not thrown ")
except LdbError as e:
(err, _) = e.args
- self.assertEquals(err, ERR_OPERATIONS_ERROR)
+ self.assertEqual(err, ERR_OPERATIONS_ERROR)
existing = open(existing_name, "r")
contents = existing.readline()
- self.assertEquals("This is not a tdb file!!!!!!\n", contents)
+ self.assertEqual("This is not a tdb file!!!!!!\n", contents)
# Attempt to open and existing non tdb file as a tdb file.
# Don't create new db is cleared
existing = open(existing_name, "rb")
contents = existing.readline()
- self.assertEquals(b"TDB file\n", contents)
+ self.assertEqual(b"TDB file\n", contents)
#
# Attempt to open an existing tdb file as a tdb file.
})
cn = initial.searchone("cn", dn)
- self.assertEquals(b"test_dont_create_db_existing_tdb_file", cn)
+ self.assertEqual(b"test_dont_create_db_existing_tdb_file", cn)
second = SamDB(url="tdb://" + existing_name)
cn = second.searchone("cn", dn)
- self.assertEquals(b"test_dont_create_db_existing_tdb_file", cn)
+ self.assertEqual(b"test_dont_create_db_existing_tdb_file", cn)
#
# Attempt to open an existing tdb file as a tdb file.
})
cn = initial.searchone("cn", dn)
- self.assertEquals(b"test_dont_create_db_existing_tdb_file", cn)
+ self.assertEqual(b"test_dont_create_db_existing_tdb_file", cn)
second = SamDB(url="tdb://" + existing_name, flags=0)
cn = second.searchone("cn", dn)
- self.assertEquals(b"test_dont_create_db_existing_tdb_file", cn)
+ self.assertEqual(b"test_dont_create_db_existing_tdb_file", cn)
# Open a non existent TDB file.
# Don't create new db is set, the default
self.fail("Exception not thrown ")
except LdbError as e1:
(err, _) = e1.args
- self.assertEquals(err, ERR_OPERATIONS_ERROR)
+ self.assertEqual(err, ERR_OPERATIONS_ERROR)
try:
file = open(self.tempdir + "/test.db", "r")
self.fail("New database file created")
except IOError as e:
- self.assertEquals(e.errno, errno.ENOENT)
+ self.assertEqual(e.errno, errno.ENOENT)
# Open a SamDB with the don't create new DB flag cleared.
# The underlying database file does not exist.
SamDB(url="tdb://" + self.tempdir + "/test.db", flags=0)
existing = open(self.tempdir + "/test.db", mode="rb")
contents = existing.readline()
- self.assertEquals(b"TDB file\n", contents)
+ self.assertEqual(b"TDB file\n", contents)
def test_from_sddl(self):
desc = security.descriptor.from_sddl("O:AOG:DAD:(A;;RPWPCCDCLCSWRCWDWOGA;;;S-1-0-0)", security.dom_sid("S-2-0-0"))
- self.assertEquals(desc.group_sid, security.dom_sid('S-2-0-0-512'))
- self.assertEquals(desc.owner_sid, security.dom_sid('S-1-5-32-548'))
- self.assertEquals(desc.revision, 1)
- self.assertEquals(desc.sacl, None)
- self.assertEquals(desc.type, 0x8004)
+ self.assertEqual(desc.group_sid, security.dom_sid('S-2-0-0-512'))
+ self.assertEqual(desc.owner_sid, security.dom_sid('S-1-5-32-548'))
+ self.assertEqual(desc.revision, 1)
+ self.assertEqual(desc.sacl, None)
+ self.assertEqual(desc.type, 0x8004)
def test_from_sddl_invalidsddl(self):
self.assertRaises(TypeError, security.descriptor.from_sddl, "foo", security.dom_sid("S-2-0-0"))
dom = security.dom_sid("S-2-0-0")
desc1 = security.descriptor.from_sddl(text, dom)
desc2 = security.descriptor.from_sddl(desc1.as_sddl(dom), dom)
- self.assertEquals(desc1.group_sid, desc2.group_sid)
- self.assertEquals(desc1.owner_sid, desc2.owner_sid)
- self.assertEquals(desc1.sacl, desc2.sacl)
- self.assertEquals(desc1.type, desc2.type)
+ self.assertEqual(desc1.group_sid, desc2.group_sid)
+ self.assertEqual(desc1.owner_sid, desc2.owner_sid)
+ self.assertEqual(desc1.sacl, desc2.sacl)
+ self.assertEqual(desc1.type, desc2.type)
def test_as_sddl_invalid(self):
text = "O:AOG:DAD:(A;;RPWPCCDCLCSWRCWDWOGA;;;S-1-0-0)"
text = "O:AOG:DAD:(A;;RPWPCCDCLCSWRCWDWOGA;;;S-1-0-0)"
desc1 = security.descriptor.from_sddl(text, dom)
desc2 = security.descriptor.from_sddl(desc1.as_sddl(), dom)
- self.assertEquals(desc1.group_sid, desc2.group_sid)
- self.assertEquals(desc1.owner_sid, desc2.owner_sid)
- self.assertEquals(desc1.sacl, desc2.sacl)
- self.assertEquals(desc1.type, desc2.type)
+ self.assertEqual(desc1.group_sid, desc2.group_sid)
+ self.assertEqual(desc1.owner_sid, desc2.owner_sid)
+ self.assertEqual(desc1.sacl, desc2.sacl)
+ self.assertEqual(desc1.type, desc2.type)
def test_domsid_nodomsid_as_sddl(self):
dom = security.dom_sid("S-2-0-0")
def test_split(self):
dom = security.dom_sid("S-2-0-7")
- self.assertEquals((security.dom_sid("S-2-0"), 7), dom.split())
+ self.assertEqual((security.dom_sid("S-2-0"), 7), dom.split())
class DomSidTests(samba.tests.TestCase):
def test_parse_sid(self):
sid = security.dom_sid("S-1-5-21")
- self.assertEquals("S-1-5-21", str(sid))
+ self.assertEqual("S-1-5-21", str(sid))
def test_sid_equal(self):
sid1 = security.dom_sid("S-1-5-21")
sid2 = security.dom_sid("S-1-5-21")
- self.assertEquals(sid1, sid1)
- self.assertEquals(sid1, sid2)
+ self.assertEqual(sid1, sid1)
+ self.assertEqual(sid1, sid2)
def test_random(self):
sid = security.random_sid()
class PrivilegeTests(samba.tests.TestCase):
def test_privilege_name(self):
- self.assertEquals("SeShutdownPrivilege",
+ self.assertEqual("SeShutdownPrivilege",
security.privilege_name(security.SEC_PRIV_SHUTDOWN))
def test_privilege_id(self):
- self.assertEquals(security.SEC_PRIV_SHUTDOWN,
+ self.assertEqual(security.SEC_PRIV_SHUTDOWN,
security.privilege_id("SeShutdownPrivilege"))
self.smb_conn.savefile(test_file, test_contents.encode('utf8'))
contents = self.smb_conn.loadfile(test_file)
- self.assertEquals(contents.decode('utf8'), test_contents,
+ self.assertEqual(contents.decode('utf8'), test_contents,
msg='contents of test file did not match what was written')
# check we can overwrite the file with new contents
new_contents = 'wxyz' * 128
self.smb_conn.savefile(test_file, new_contents.encode('utf8'))
contents = self.smb_conn.loadfile(test_file)
- self.assertEquals(contents.decode('utf8'), new_contents,
+ self.assertEqual(contents.decode('utf8'), new_contents,
msg='contents of test file did not match what was written')
# with python2 this will save/load str type (with embedded nulls)
self.smb_conn.savefile(test_file, test_literal_bytes_embed_nulls)
contents = self.smb_conn.loadfile(test_file)
- self.assertEquals(contents, test_literal_bytes_embed_nulls,
+ self.assertEqual(contents, test_literal_bytes_embed_nulls,
msg='contents of test file did not match what was written')
# python3 only this will save/load unicode
self.smb_conn.savefile(test_file, utf_contents.encode('utf8'))
contents = self.smb_conn.loadfile(test_file)
- self.assertEquals(contents.decode('utf8'), utf_contents,
+ self.assertEqual(contents.decode('utf8'), utf_contents,
msg='contents of test file did not match what was written')
# with python2 this will save/load str type
self.smb_conn.savefile(test_file, binary_contents)
contents = self.smb_conn.loadfile(test_file)
- self.assertEquals(contents, binary_contents,
+ self.assertEqual(contents, binary_contents,
msg='contents of test file did not match what was written')
def make_sysvol_path(self, dirpath, filename):
(KATAKANA_LETTER_A, 'a', 1),
]
for a, b, expect in cases:
- self.assertEquals(signum(strcasecmp_m(a, b)), expect)
+ self.assertEqual(signum(strcasecmp_m(a, b)), expect)
class strstr_m_Tests(samba.tests.TestCase):
(KATAKANA_LETTER_A * 3, 'a', None),
]
for a, b, expect in cases:
- self.assertEquals(strstr_m(a, b), expect)
+ self.assertEqual(strstr_m(a, b), expect)
}
import_wins(self.ldb, winsdb)
- self.assertEquals(
+ self.assertEqual(
['name=FOO,type=0x20'],
[str(m.dn) for m in
self.ldb.search(expression="(objectClass=winsRecord)")])
def test_version(self):
import_wins(self.ldb, {})
- self.assertEquals("VERSION",
+ self.assertEqual("VERSION",
str(self.ldb.search(expression="(objectClass=winsMaxVersion)")[0]["cn"]))
# higher level comes after lower even if lexicographicaly closer
# ie dc=tata,dc=toto (2 levels), comes after dc=toto
# even if dc=toto is lexicographicaly after dc=tata, dc=toto
- self.assertEquals(dn_sort("dc=tata,dc=toto", "dc=toto"), 1)
- self.assertEquals(dn_sort("dc=zata", "dc=tata"), 1)
- self.assertEquals(dn_sort("dc=toto,dc=tata",
+ self.assertEqual(dn_sort("dc=tata,dc=toto", "dc=toto"), 1)
+ self.assertEqual(dn_sort("dc=zata", "dc=tata"), 1)
+ self.assertEqual(dn_sort("dc=toto,dc=tata",
"cn=foo,dc=toto,dc=tata"), -1)
- self.assertEquals(dn_sort("cn=bar, dc=toto,dc=tata",
+ self.assertEqual(dn_sort("cn=bar, dc=toto,dc=tata",
"cn=foo, dc=toto,dc=tata"), -1)
def test_get_diff_sds(self):
(A;CI;RPWPCRCCLCLORCWOWDSW;;;SA)\
(A;CI;RP LCLORC;;;AU)(A;CI;RPWPCRCCDCLCLORCWOWDSDDTSW;;;SY)S:AI(AU;CISA;WP;;;WD)(AU;CIIDSA;WP;;;WD)"
- self.assertEquals(get_diff_sds(security.descriptor.from_sddl(sddl, domsid),
+ self.assertEqual(get_diff_sds(security.descriptor.from_sddl(sddl, domsid),
security.descriptor.from_sddl(sddl1, domsid),
domsid), "")
txt = get_diff_sds(security.descriptor.from_sddl(sddl, domsid),
security.descriptor.from_sddl(sddl2, domsid),
domsid)
- self.assertEquals(txt, "\tOwner mismatch: SA (in ref) BA(in current)\n")
+ self.assertEqual(txt, "\tOwner mismatch: SA (in ref) BA(in current)\n")
txt = get_diff_sds(security.descriptor.from_sddl(sddl, domsid),
security.descriptor.from_sddl(sddl3, domsid),
domsid)
- self.assertEquals(txt, "\tGroup mismatch: DU (in ref) BA(in current)\n")
+ self.assertEqual(txt, "\tGroup mismatch: DU (in ref) BA(in current)\n")
txt = get_diff_sds(security.descriptor.from_sddl(sddl, domsid),
security.descriptor.from_sddl(sddl4, domsid),
domsid)
is the detail:\n\t\t(A;CI;RPWPCRCCLCLORCWOWDSW;;;BA) ACE is not present in\
the reference\n\t\t(A;CI;RPWPCRCCLCLORCWOWDSW;;;SA) ACE is not present in\
the current\n"
- self.assertEquals(txt, txtmsg)
+ self.assertEqual(txt, txtmsg)
txt = get_diff_sds(security.descriptor.from_sddl(sddl, domsid),
security.descriptor.from_sddl(sddl5, domsid),
domsid)
- self.assertEquals(txt, "\tCurrent ACL hasn't a sacl part\n")
- self.assertEquals(get_diff_sds(security.descriptor.from_sddl(sddl, domsid),
+ self.assertEqual(txt, "\tCurrent ACL hasn't a sacl part\n")
+ self.assertEqual(get_diff_sds(security.descriptor.from_sddl(sddl, domsid),
security.descriptor.from_sddl(sddl6, domsid),
domsid), "")
def test_construct_existor_expr(self):
res = construct_existor_expr([])
- self.assertEquals(res, "")
+ self.assertEqual(res, "")
res = construct_existor_expr(["foo"])
- self.assertEquals(res, "(|(foo=*))")
+ self.assertEqual(res, "(|(foo=*))")
res = construct_existor_expr(["foo", "bar"])
- self.assertEquals(res, "(|(foo=*)(bar=*))")
+ self.assertEqual(res, "(|(foo=*)(bar=*))")
class UpdateSecretsTests(samba.tests.TestCaseInTempDir):
def test_trivial(self):
# Test that updating an already up-to-date secretsdb works fine
self.secretsdb = self._getCurrentFormatDb()
- self.assertEquals(None,
+ self.assertEqual(None,
update_secrets(self.referencedb, self.secretsdb, dummymessage))
def test_update_modules(self):
update_secrets(self.referencedb, empty_db, dummymessage)
newmodules = empty_db.search(base="@MODULES", scope=SCOPE_BASE)
refmodules = self.referencedb.search(base="@MODULES", scope=SCOPE_BASE)
- self.assertEquals(newmodules.msgs, refmodules.msgs)
+ self.assertEqual(newmodules.msgs, refmodules.msgs)
def tearDown(self):
for name in ["ref.ldb", "secrets.ldb", "secrets.tdb", "secrets.tdb.bak", "secrets.ntdb"]:
ldbs = get_ldbs(paths, creds, system_session(), lp)
names = find_provision_key_parameters(ldbs.sam, ldbs.secrets, ldbs.idmap,
paths, smb_conf_path, lp)
- self.assertEquals(names.realm, "SAMBA.EXAMPLE.COM")
- self.assertEquals(str(names.rootdn).lower(), rootdn.lower())
+ self.assertEqual(names.realm, "SAMBA.EXAMPLE.COM")
+ self.assertEqual(str(names.rootdn).lower(), rootdn.lower())
self.assertNotEquals(names.policyid_dc, None)
self.assertNotEquals(names.ntdsguid, "")
identic_rename(self.ldbs.sam, guestDN)
res = self.ldbs.sam.search(expression="(name=Guest)", base=rootdn,
scope=ldb.SCOPE_SUBTREE, attrs=["dn"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["dn"]), "CN=Guest,CN=Users,%s" % rootdn)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["dn"]), "CN=Guest,CN=Users,%s" % rootdn)
def test_delta_update_basesamdb(self):
dummysampath = self._getEmptyDbName()
try:
samba.xattr_native.wrap_setxattr(tempf, "user.unittests", reftxt)
text = samba.xattr_native.wrap_getxattr(tempf, "user.unittests")
- self.assertEquals(text, reftxt)
+ self.assertEqual(text, reftxt)
except IOError:
raise SkipTest("the filesystem where the tests are runned do not support XATTR")
os.unlink(tempf)
reftxt)
text = samba.xattr_tdb.wrap_getxattr(eadb_path, tempf,
"user.unittests")
- self.assertEquals(text, reftxt)
+ self.assertEqual(text, reftxt)
finally:
os.unlink(tempf)
os.unlink(eadb_path)
reftxt)
text = samba.posix_eadb.wrap_getxattr(eadb_path, tempf,
"user.unittests")
- self.assertEquals(text, reftxt)
+ self.assertEqual(text, reftxt)
finally:
os.unlink(tempf)
os.unlink(eadb_path)
grouptype=samba.dsdb.GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP)
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
# Make sure we HAVEN'T created any of two objects -- user or group
grouptype=samba.dsdb.GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP)
except LdbError as e1:
(num, _) = e1.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
# Make sure we HAVE created the one of two objects -- user
anonymous.newuser("test_add_anonymous", self.user_pass)
except LdbError as e2:
(num, _) = e2.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
else:
self.fail()
self.ldb_user.modify_ldif(ldif)
except LdbError as e3:
(num, _) = e3.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
self.fail()
self.ldb_user.modify_ldif(ldif)
except LdbError as e4:
(num, _) = e4.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
self.fail()
self.ldb_user.modify_ldif(ldif)
except LdbError as e5:
(num, _) = e5.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
self.fail()
self.ldb_user.modify_ldif(ldif)
except LdbError as e6:
(num, _) = e6.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
self.fail()
self.ldb_user.modify_ldif(ldif)
except LdbError as e7:
(num, _) = e7.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
self.fail()
self.ldb_user.modify_ldif(ldif)
except LdbError as e8:
(num, _) = e8.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
self.fail()
self.ldb_user.modify_ldif(ldif)
except LdbError as e9:
(num, _) = e9.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
self.fail()
self.ldb_user.modify_ldif(ldif)
except LdbError as e10:
(num, _) = e10.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
self.fail()
self.ldb_user2.modify_ldif(ldif)
except LdbError as e11:
(num, _) = e11.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This 'modify' operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
self.fail()
self.ldb_user2.modify_ldif(ldif)
except LdbError as e12:
(num, _) = e12.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
self.ldb_user2.modify_ldif(ldif)
except LdbError as e13:
(num, _) = e13.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
anonymous.modify(m)
except LdbError as e14:
(num, _) = e14.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
else:
self.fail()
"""Verify access of rootDSE with the correct request"""
anonymous = SamDB(url=ldaphost, credentials=self.creds_tmp, lp=lp)
res = anonymous.search("", expression="(objectClass=*)", scope=SCOPE_BASE)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
# verify some of the attributes
# don't care about values
self.assertTrue("ldapServiceName" in res[0])
res = anonymous.search("", expression="(objectClass=*)", scope=SCOPE_SUBTREE)
except LdbError as e15:
(num, _) = e15.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
else:
self.fail()
try:
res = anonymous.search(self.base_dn, expression="(objectClass=*)", scope=SCOPE_SUBTREE)
except LdbError as e16:
(num, _) = e16.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
else:
self.fail()
try:
scope=SCOPE_SUBTREE)
except LdbError as e17:
(num, _) = e17.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
else:
self.fail()
anonymous = SamDB(url=ldaphost, credentials=self.creds_tmp, lp=lp)
res = anonymous.search("OU=test_search_ou2,OU=test_search_ou1," + self.base_dn,
expression="(objectClass=*)", scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertTrue("dn" in res[0])
self.assertTrue(res[0]["dn"] == Dn(self.ldb_admin,
"OU=test_search_ou2,OU=test_search_ou1," + self.base_dn))
res = anonymous.search(anonymous.get_config_basedn(), expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertTrue("dn" in res[0])
self.assertTrue(res[0]["dn"] == Dn(self.ldb_admin, self.configuration_dn))
# regular users must see only ou1 and ou2
res = self.ldb_user3.search("OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 2)
+ self.assertEqual(len(res), 2)
ok_list = [Dn(self.ldb_admin, "OU=ou2,OU=ou1," + self.base_dn),
Dn(self.ldb_admin, "OU=ou1," + self.base_dn)]
res_list = [x["dn"] for x in res if x["dn"] in ok_list]
- self.assertEquals(sorted(res_list), sorted(ok_list))
+ self.assertEqual(sorted(res_list), sorted(ok_list))
# these users should see all ous
res = self.ldb_user.search("OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 6)
+ self.assertEqual(len(res), 6)
res_list = [x["dn"] for x in res if x["dn"] in self.full_list]
- self.assertEquals(sorted(res_list), sorted(self.full_list))
+ self.assertEqual(sorted(res_list), sorted(self.full_list))
res = self.ldb_user2.search("OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 6)
+ self.assertEqual(len(res), 6)
res_list = [x["dn"] for x in res if x["dn"] in self.full_list]
- self.assertEquals(sorted(res_list), sorted(self.full_list))
+ self.assertEqual(sorted(res_list), sorted(self.full_list))
def test_search2(self):
"""Make sure users can't see us if access is explicitly denied"""
scope=SCOPE_SUBTREE)
# this user should see all ous
res_list = [x["dn"] for x in res if x["dn"] in self.full_list]
- self.assertEquals(sorted(res_list), sorted(self.full_list))
+ self.assertEqual(sorted(res_list), sorted(self.full_list))
# these users should see ou1, 2, 5 and 6 but not 3 and 4
res = self.ldb_user.search("OU=ou1," + self.base_dn, expression="(objectClass=*)",
Dn(self.ldb_admin, "OU=ou5,OU=ou3,OU=ou2,OU=ou1," + self.base_dn),
Dn(self.ldb_admin, "OU=ou6,OU=ou4,OU=ou2,OU=ou1," + self.base_dn)]
res_list = [x["dn"] for x in res if x["dn"] in ok_list]
- self.assertEquals(sorted(res_list), sorted(ok_list))
+ self.assertEqual(sorted(res_list), sorted(ok_list))
res = self.ldb_user2.search("OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 4)
+ self.assertEqual(len(res), 4)
res_list = [x["dn"] for x in res if x["dn"] in ok_list]
- self.assertEquals(sorted(res_list), sorted(ok_list))
+ self.assertEqual(sorted(res_list), sorted(ok_list))
def test_search3(self):
"""Make sure users can't see ous if access is explicitly denied - 2"""
scope=SCOPE_BASE)
except LdbError as e18:
(num, _) = e18.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
else:
self.fail()
res = self.ldb_user3.search("OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
res_list = [x["dn"] for x in res if x["dn"] in ok_list]
- self.assertEquals(sorted(res_list), sorted(ok_list))
+ self.assertEqual(sorted(res_list), sorted(ok_list))
ok_list = [Dn(self.ldb_admin, "OU=ou2,OU=ou1," + self.base_dn),
Dn(self.ldb_admin, "OU=ou1," + self.base_dn),
# should not see ou3 and ou4, but should see ou5 and ou6
res = self.ldb_user.search("OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 4)
+ self.assertEqual(len(res), 4)
res_list = [x["dn"] for x in res if x["dn"] in ok_list]
- self.assertEquals(sorted(res_list), sorted(ok_list))
+ self.assertEqual(sorted(res_list), sorted(ok_list))
res = self.ldb_user2.search("OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 4)
+ self.assertEqual(len(res), 4)
res_list = [x["dn"] for x in res if x["dn"] in ok_list]
- self.assertEquals(sorted(res_list), sorted(ok_list))
+ self.assertEqual(sorted(res_list), sorted(ok_list))
def test_search4(self):
"""There is no difference in visibility if the user is also creator"""
Dn(self.ldb_admin, "OU=ou1," + self.base_dn)]
res = self.ldb_user3.search("OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 2)
+ self.assertEqual(len(res), 2)
res_list = [x["dn"] for x in res if x["dn"] in ok_list]
- self.assertEquals(sorted(res_list), sorted(ok_list))
+ self.assertEqual(sorted(res_list), sorted(ok_list))
res = self.ldb_user.search("OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 2)
+ self.assertEqual(len(res), 2)
res_list = [x["dn"] for x in res if x["dn"] in ok_list]
- self.assertEquals(sorted(res_list), sorted(ok_list))
+ self.assertEqual(sorted(res_list), sorted(ok_list))
def test_search5(self):
"""Make sure users can see only attributes they are allowed to see"""
res = self.ldb_user.search("OU=ou2,OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
ok_list = ['dn']
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
res_list = list(res[0].keys())
- self.assertEquals(res_list, ok_list)
+ self.assertEqual(res_list, ok_list)
res = self.ldb_user.search("OU=ou2,OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_BASE, attrs=["ou"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
res_list = list(res[0].keys())
- self.assertEquals(res_list, ok_list)
+ self.assertEqual(res_list, ok_list)
# give read property on ou and assert user can only see dn and ou
mod = "(OA;;RP;bf9679f0-0de6-11d0-a285-00aa003049e2;;%s)" % (str(self.user_sid))
res = self.ldb_user.search("OU=ou2,OU=ou1," + self.base_dn, expression="(objectClass=*)",
scope=SCOPE_SUBTREE)
ok_list = ['dn', 'ou']
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
res_list = list(res[0].keys())
- self.assertEquals(sorted(res_list), sorted(ok_list))
+ self.assertEqual(sorted(res_list), sorted(ok_list))
# give read property on Public Information and assert user can see ou and other members
mod = "(OA;;RP;e48d0154-bcf8-11d1-8702-00c04fb96050;;%s)" % (str(self.user_sid))
ok_list = ['dn', 'objectClass', 'ou', 'distinguishedName', 'name', 'objectGUID', 'objectCategory']
res_list = list(res[0].keys())
- self.assertEquals(sorted(res_list), sorted(ok_list))
+ self.assertEqual(sorted(res_list), sorted(ok_list))
def test_search6(self):
"""If an attribute that cannot be read is used in a filter, it is as if the attribute does not exist"""
res = self.ldb_user.search("OU=ou1," + self.base_dn, expression="(ou=ou3)",
scope=SCOPE_SUBTREE)
# nothing should be returned as ou is not accessible
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# give read property on ou and assert user can only see dn and ou
mod = "(OA;;RP;bf9679f0-0de6-11d0-a285-00aa003049e2;;%s)" % (str(self.user_sid))
self.sd_utils.dacl_add_ace("OU=ou3,OU=ou2,OU=ou1," + self.base_dn, mod)
res = self.ldb_user.search("OU=ou1," + self.base_dn, expression="(ou=ou3)",
scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
ok_list = ['dn', 'ou']
res_list = list(res[0].keys())
- self.assertEquals(sorted(res_list), sorted(ok_list))
+ self.assertEqual(sorted(res_list), sorted(ok_list))
# give read property on Public Information and assert user can see ou and other members
mod = "(OA;;RP;e48d0154-bcf8-11d1-8702-00c04fb96050;;%s)" % (str(self.user_sid))
self.sd_utils.dacl_add_ace("OU=ou2,OU=ou1," + self.base_dn, mod)
res = self.ldb_user.search("OU=ou1," + self.base_dn, expression="(ou=ou2)",
scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
ok_list = ['dn', 'objectClass', 'ou', 'distinguishedName', 'name', 'objectGUID', 'objectCategory']
res_list = list(res[0].keys())
- self.assertEquals(sorted(res_list), sorted(ok_list))
+ self.assertEqual(sorted(res_list), sorted(ok_list))
def assert_search_on_attr(self, dn, samdb, attr, expected_list):
expected_num = len(expected_list)
res = samdb.search(dn, expression="(%s=*)" % attr, scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), expected_num)
+ self.assertEqual(len(res), expected_num)
res_list = [ x["dn"] for x in res if x["dn"] in expected_list ]
- self.assertEquals(sorted(res_list), sorted(expected_list))
+ self.assertEqual(sorted(res_list), sorted(expected_list))
def test_search7(self):
"""Checks object search visibility when users don't have full rights"""
self.ldb_user.delete(self.get_user_dn("test_delete_user1"))
except LdbError as e19:
(num, _) = e19.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
anonymous.delete(self.get_user_dn("test_anonymous"))
except LdbError as e20:
(num, _) = e20.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
else:
self.fail()
"CN=%s,%s,%s" % (self.testuser5, self.ou1, self.base_dn))
except LdbError as e21:
(num, _) = e21.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
self.ldb_user.rename(ou2_dn, ou3_dn)
except LdbError as e22:
(num, _) = e22.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
# This rename operation should always throw ERR_INSUFFICIENT_ACCESS_RIGHTS
self.fail()
self.ldb_admin.rename(user_dn, rename_user_dn)
except LdbError as e23:
(num, _) = e23.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
# add an allow ace so we can delete this ou
""")
except LdbError as e24:
(num, _) = e24.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
else:
# for some reason we get constraint violation instead of insufficient access error
self.fail()
""")
except LdbError as e25:
(num, _) = e25.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
else:
# for some reason we get constraint violation instead of insufficient access error
self.fail()
""")
except LdbError as e26:
(num, _) = e26.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
else:
self.fail()
""")
except LdbError as e27:
(num, _) = e27.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
mod = "(OA;;CR;00299570-246d-11d0-a768-00aa006e0529;;PS)"
""")
except LdbError as e29:
(num, _) = e29.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
mod = "(OA;;CR;00299570-246d-11d0-a768-00aa006e0529;;PS)"
""")
except LdbError as e30:
(num, _) = e30.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
mod = "(OA;;CR;00299570-246d-11d0-a768-00aa006e0529;;PS)"
# This fails on Windows 2000 domain level with constraint violation
except LdbError as e31:
(num, _) = e31.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
def test_reset_password3(self):
"""Grant WP and see what happens (unicodePwd)"""
""")
except LdbError as e32:
(num, _) = e32.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
""")
except LdbError as e33:
(num, _) = e33.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
# This fails on Windows 2000 domain level with constraint violation
except LdbError as e34:
(num, _) = e34.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
class AclExtendedTests(AclTests):
self.ldb_admin.delete(self.get_user_dn(new_user))
res = self.ldb_admin.search(base="<GUID=%s>" % self.GUID_string(guid),
scope=SCOPE_BASE, controls=["show_deleted:1"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
return str(res[0].dn)
def undelete_deleted(self, olddn, newdn):
self.fail()
except LdbError as e35:
(num, _) = e35.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
# seems that permissions on isDeleted and distinguishedName are irrelevant
mod = "(OD;;WP;bf96798f-0de6-11d0-a285-00aa003049e2;;%s)" % str(self.sid)
self.fail()
except LdbError as e36:
(num, _) = e36.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
# undelete in an ou, in which we have no right to create children
mod = "(D;;CC;;;%s)" % str(self.sid)
self.fail()
except LdbError as e37:
(num, _) = e37.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
# delete is not required
mod = "(D;;SD;;;%s)" % str(self.sid)
self.fail()
except LdbError as e38:
(num, _) = e38.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
class AclSPNTests(AclTests):
self.replace_spn(self.ldb_user1, ctx.acct_dn, "HOST/%s/%s" % (ctx.myname, netbiosdomain))
except LdbError as e39:
(num, _) = e39.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
mod = "(OA;;SW;f3a64788-5306-11d1-a9c5-0000f80367c1;;%s)" % str(self.user_sid1)
self.sd_utils.dacl_add_ace(ctx.acct_dn, mod)
(ctx.myname, ctx.dnsdomain, ctx.dnsdomain))
except LdbError as e40:
(num, _) = e40.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, ctx.acct_dn, "ldap/%s.%s/DomainDnsZones.%s" %
(ctx.myname, ctx.dnsdomain, ctx.dnsdomain))
except LdbError as e41:
(num, _) = e41.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, ctx.acct_dn, "nosuchservice/%s/%s" % ("abcd", "abcd"))
except LdbError as e42:
(num, _) = e42.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, ctx.acct_dn, "GC/%s.%s/%s" %
(ctx.myname, ctx.dnsdomain, netbiosdomain))
except LdbError as e43:
(num, _) = e43.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, ctx.acct_dn, "E3514235-4B06-11D1-AB04-00C04FC2DCD2/%s/%s" %
(ctx.ntds_guid, ctx.dnsdomain))
except LdbError as e44:
(num, _) = e44.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
def test_computer_spn(self):
# with WP, any value can be set
self.replace_spn(self.ldb_user1, self.computerdn, "HOST/%s/%s" % (self.computername, netbiosdomain))
except LdbError as e45:
(num, _) = e45.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
mod = "(OA;;SW;f3a64788-5306-11d1-a9c5-0000f80367c1;;%s)" % str(self.user_sid1)
self.sd_utils.dacl_add_ace(self.computerdn, mod)
self.replace_spn(self.ldb_user1, self.computerdn, "HOST/%s/%s" % (self.computername, netbiosdomain))
except LdbError as e46:
(num, _) = e46.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "HOST/%s.%s/%s" %
(self.computername, self.dcctx.dnsdomain, netbiosdomain))
except LdbError as e47:
(num, _) = e47.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "HOST/%s/%s" %
(self.computername, self.dcctx.dnsdomain))
except LdbError as e48:
(num, _) = e48.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "HOST/%s.%s/%s" %
(self.computername, self.dcctx.dnsdomain, self.dcctx.dnsdomain))
except LdbError as e49:
(num, _) = e49.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "GC/%s.%s/%s" %
(self.computername, self.dcctx.dnsdomain, self.dcctx.dnsforest))
except LdbError as e50:
(num, _) = e50.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "ldap/%s/%s" % (self.computername, netbiosdomain))
except LdbError as e51:
(num, _) = e51.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.replace_spn(self.ldb_user1, self.computerdn, "ldap/%s.%s/ForestDnsZones.%s" %
(self.computername, self.dcctx.dnsdomain, self.dcctx.dnsdomain))
except LdbError as e52:
(num, _) = e52.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
def test_spn_rwdc(self):
self.dc_spn_test(self.dcctx)
scope=SCOPE_BASE,
controls=["show_deleted:1"],
attrs=["*", "parentGUID"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
return res[0]
def search_dn(self, dn):
scope=SCOPE_BASE,
controls=["show_deleted:1"],
attrs=["*", "parentGUID"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
return res[0]
def del_attr_values(self, delObj):
print("Checking attributes for %s" % delObj["dn"])
- self.assertEquals(str(delObj["isDeleted"][0]), "TRUE")
+ self.assertEqual(str(delObj["isDeleted"][0]), "TRUE")
self.assertTrue(not("objectCategory" in delObj))
self.assertTrue(not("sAMAccountType" in delObj))
name2 = delObj["name"][0]
dn_rdn = delObj.dn.get_rdn_value()
guid = liveObj["objectGUID"][0]
- self.assertEquals(str(rdn2), ("%s\nDEL:%s" % (rdn, self.GUID_string(guid))))
- self.assertEquals(str(name2), ("%s\nDEL:%s" % (rdn, self.GUID_string(guid))))
- self.assertEquals(str(name2), dn_rdn)
+ self.assertEqual(str(rdn2), ("%s\nDEL:%s" % (rdn, self.GUID_string(guid))))
+ self.assertEqual(str(name2), ("%s\nDEL:%s" % (rdn, self.GUID_string(guid))))
+ self.assertEqual(str(name2), dn_rdn)
def delete_deleted(self, ldb, dn):
print("Testing the deletion of the already deleted dn %s" % dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
def test_delete_protection(self):
"""Delete protection tests"""
self.fail()
except LdbError as e1:
(num, _) = e1.args
- self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
+ self.assertEqual(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
self.ldb.delete("cn=ldaptestcontainer," + self.base_dn, ["tree_delete:1"])
self.fail()
except LdbError as e2:
(num, _) = e2.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
try:
res = self.ldb.search("cn=entry1,cn=ldaptestcontainer," + self.base_dn,
scope=SCOPE_BASE, attrs=[])
self.fail()
except LdbError as e3:
(num, _) = e3.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
try:
res = self.ldb.search("cn=entry2,cn=ldaptestcontainer," + self.base_dn,
scope=SCOPE_BASE, attrs=[])
self.fail()
except LdbError as e4:
(num, _) = e4.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
delete_force(self.ldb, "cn=entry1,cn=ldaptestcontainer," + self.base_dn)
delete_force(self.ldb, "cn=entry2,cn=ldaptestcontainer," + self.base_dn)
res = self.ldb.search(base="", expression="", scope=SCOPE_BASE,
attrs=["dsServiceName", "dNSHostName"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
# Delete failing since DC's nTDSDSA object is protected
try:
self.fail()
except LdbError as e5:
(num, _) = e5.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
res = self.ldb.search(self.base_dn, attrs=["rIDSetReferences"],
expression="(&(objectClass=computer)(dNSHostName=" + str(res[0]["dNSHostName"][0]) + "))")
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
# Deletes failing since DC's rIDSet object is protected
try:
self.fail()
except LdbError as e6:
(num, _) = e6.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.delete(res[0]["rIDSetReferences"][0], ["tree_delete:1"])
self.fail()
except LdbError as e7:
(num, _) = e7.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Deletes failing since three main crossRef objects are protected
self.fail()
except LdbError as e8:
(num, _) = e8.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.delete("cn=Enterprise Schema,cn=Partitions," + self.configuration_dn, ["tree_delete:1"])
self.fail()
except LdbError as e9:
(num, _) = e9.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.delete("cn=Enterprise Configuration,cn=Partitions," + self.configuration_dn)
self.fail()
except LdbError as e10:
(num, _) = e10.args
- self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
+ self.assertEqual(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
try:
self.ldb.delete("cn=Enterprise Configuration,cn=Partitions," + self.configuration_dn, ["tree_delete:1"])
self.fail()
except LdbError as e11:
(num, _) = e11.args
- self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
+ self.assertEqual(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
res = self.ldb.search("cn=Partitions," + self.configuration_dn, attrs=[],
expression="(nCName=%s)" % self.base_dn)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
try:
self.ldb.delete(res[0].dn)
self.fail()
except LdbError as e12:
(num, _) = e12.args
- self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
+ self.assertEqual(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
try:
self.ldb.delete(res[0].dn, ["tree_delete:1"])
self.fail()
except LdbError as e13:
(num, _) = e13.args
- self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
+ self.assertEqual(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
# Delete failing since "SYSTEM_FLAG_DISALLOW_DELETE"
try:
self.fail()
except LdbError as e14:
(num, _) = e14.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Tree-delete failing since "isCriticalSystemObject"
try:
self.fail()
except LdbError as e15:
(num, _) = e15.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
class BasicTreeDeleteTests(BasicDeleteTests):
expression="(distinguishedName=%s)" % str(self.base_dn),
attrs=["objectGUID"],
controls=["dirsync:1:0:1"])
- self.assertEquals(len(res.msgs), 0)
+ self.assertEqual(len(res.msgs), 0)
# a request on the root of a NC didn't return parentGUID
res = self.ldb_admin.search(self.base_dn,
controls=["dirsync:1:0:0"])
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS)
else:
self.fail()
# fetch rootDSE
res = self.sam_db.search(base="", expression="", scope=SCOPE_BASE, attrs=["*"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.schema_dn = res[0]["schemaNamingContext"][0]
self.base_dn = res[0]["defaultNamingContext"][0]
self.forest_level = int(res[0]["forestFunctionality"][0])
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
# Invalid objectclass specified
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(num, ERR_NO_SUCH_ATTRIBUTE)
# Invalid objectCategory specified
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# Multi-valued "systemFlags"
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
# We cannot instanciate from an abstract object class ("connectionPoint"
# or "leaf"). In the first case we use "connectionPoint" (subclass of
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.add({
"dn": "cn=ldaptestuser,cn=users," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# Objects instanciated using "satisfied" abstract classes (concrete
# subclasses) are allowed
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# Test allowed system flags
self.ldb.add({
res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["systemFlags"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["systemFlags"][0]), "0")
+ self.assertEqual(str(res[0]["systemFlags"][0]), "0")
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# We cannot delete classes which weren't specified
m = Message()
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(num, ERR_NO_SUCH_ATTRIBUTE)
# An invalid class cannot be added
m = Message()
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(num, ERR_NO_SUCH_ATTRIBUTE)
# We cannot add a the new top-most structural class "user" here since
# we are missing at least one new mandatory attribute (in this case
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# An already specified objectclass cannot be added another time
m = Message()
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
# Auxiliary classes can always be added
m = Message()
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# Objectclass replace operations can be performed as well
m = Message()
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# More than one change operation is allowed
m = Message()
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# Classes can be removed unless attributes of them are used.
m = Message()
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# Remove the previously specified attribute
m = Message()
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# Add a new top-most structural class "inetOrgPerson" and remove it
# afterwards
res = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["objectClass"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["objectClass"][0]), "top")
- self.assertEquals(str(res[0]["objectClass"][len(res[0]["objectClass"]) - 1]), "user")
+ self.assertEqual(str(res[0]["objectClass"][0]), "top")
+ self.assertEqual(str(res[0]["objectClass"][len(res[0]["objectClass"]) - 1]), "user")
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.add({
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
delete_force(self.ldb, "cn=Test Secret,cn=system," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=Test Secret,cn=system," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
self.ldb.add({
"dn": "cn=ldaptestcontainer," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
attrs=["isCriticalSystemObject"])
self.assertTrue(len(res) == 1)
self.assertTrue("isCriticalSystemObject" in res[0])
- self.assertEquals(str(res[0]["isCriticalSystemObject"][0]), "TRUE")
+ self.assertEqual(str(res[0]["isCriticalSystemObject"][0]), "TRUE")
def test_invalid_parent(self):
"""Test adding an object with invalid parent"""
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
delete_force(self.ldb, "cn=ldaptestgroup,cn=thisdoesnotexist123,"
+ self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NAMING_VIOLATION)
+ self.assertEqual(num, ERR_NAMING_VIOLATION)
delete_force(self.ldb, "ou=testou,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(num, ERR_NO_SUCH_ATTRIBUTE)
self.ldb.add({
"dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(num, ERR_NO_SUCH_ATTRIBUTE)
#
# When searching the unknown attribute should be ignored
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# inadequate but schema-valid attribute specified
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
self.ldb.add({
"dn": "cn=ldaptestobject," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# mandatory attribute delete trial
m = Message()
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# mandatory attribute delete trial
m = Message()
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
delete_force(self.ldb, "cn=ldaptestobject," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.ldb.add({
"dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail("failed to fail to add multiple managedBy attributes")
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
managee = "cn=group2," + ou
self.ldb.add({
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
m.dn = Dn(ldb, managee)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
self.ldb.delete(ou, ['tree_delete:1'])
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
ldb.add({
"dn": "cn=ldaptestuser,cn=users," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
m = Message()
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
ldb.add({
"dn": "cn=ldaptestuser,cn=users," + self.base_dn,
ldb.modify(m)
self.fail()
except LdbError as e:
- self.assertEquals(e.args[0], ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(e.args[0], ERR_CONSTRAINT_VIOLATION)
def test_empty_messages(self):
"""Test empty messages"""
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
try:
ldb.modify(m)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.ldb.add({
"dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(num, ERR_NO_SUCH_ATTRIBUTE)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# The head NC flag cannot be set without the write flag
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# We cannot manipulate NCs without the head NC flag
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
self.ldb.add({
"dn": "cn=ldaptestgroup,cn=users," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
def test_distinguished_name(self):
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(num, ERR_NO_SUCH_ATTRIBUTE)
# a wrong "distinguishedName" attribute is obviously tolerated
self.ldb.add({
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(num, ERR_NO_SUCH_ATTRIBUTE)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
# empty RDN name
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
try:
self.ldb.search("=ldaptestgroup,cn=users," + self.base_dn, scope=SCOPE_BASE)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
# Add
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
# empty RDN name
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
# empty RDN value
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
# a wrong RDN candidate
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NAMING_VIOLATION)
+ self.assertEqual(num, ERR_NAMING_VIOLATION)
delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
# Delete
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
# Rename
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
# new empty RDN name
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
# new empty RDN value
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NAMING_VIOLATION)
+ self.assertEqual(num, ERR_NAMING_VIOLATION)
# new wrong RDN candidate
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "description=xyz,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
# names
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
+ self.assertEqual(num, ERR_NOT_ALLOWED_ON_RDN)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NOT_ALLOWED_ON_RDN)
+ self.assertEqual(num, ERR_NOT_ALLOWED_ON_RDN)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
delete_force(self.ldb, "%s,%s" % (rdn, self.base_dn))
def test_rename(self):
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
# inexistent object
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
self.ldb.add({
"dn": "cn=ldaptestuser2,cn=users," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NAMING_VIOLATION)
+ self.assertEqual(num, ERR_NAMING_VIOLATION)
try:
# invalid parent
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OTHER)
+ self.assertEqual(num, ERR_OTHER)
try:
# invalid target DN syntax
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
try:
# invalid RDN name
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestuser3,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Limited move failing since no "SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE"
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Rename failing since no "SYSTEM_FLAG_CONFIG_ALLOW_RENAME"
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# It's not really possible to test moves on the schema partition since
# there don't exist subcontainers on it.
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Move failing since "SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE"
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Rename failing since "SYSTEM_FLAG_DOMAIN_DISALLOW_RENAME"
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Performs some other constraints testing
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_OTHER)
+ self.assertEqual(num, ERR_OTHER)
def test_rename_twice(self):
"""Tests the rename operation twice - this corresponds to a past bug"""
"objectclass": "user"})
ldb.rename("cn=ldaptestuser5,cn=Users," + self.base_dn, "cn=ldaptestUSER5,cn=users," + self.base_dn)
res = ldb.search(expression="cn=ldaptestuser5")
- self.assertEquals(len(res), 1, "Wrong number of hits for cn=ldaptestuser5")
+ self.assertEqual(len(res), 1, "Wrong number of hits for cn=ldaptestuser5")
res = ldb.search(expression="(&(cn=ldaptestuser5)(objectclass=user))")
- self.assertEquals(len(res), 1, "Wrong number of hits for (&(cn=ldaptestuser5)(objectclass=user))")
+ self.assertEqual(len(res), 1, "Wrong number of hits for (&(cn=ldaptestuser5)(objectclass=user))")
delete_force(self.ldb, "cn=ldaptestuser5,cn=users," + self.base_dn)
def test_objectGUID(self):
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
self.ldb.add({
"dn": "cn=ldaptestcontainer," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
delete_force(self.ldb, "cn=ldaptestcontainer," + self.base_dn)
attrs=["parentGUID"])
"""Check if the parentGUID is valid """
- self.assertEquals(res1[0]["parentGUID"], res2[0]["objectGUID"])
+ self.assertEqual(res1[0]["parentGUID"], res2[0]["objectGUID"])
"""Check if it returns nothing when there is no parent object - default NC"""
has_parentGUID = False
break
self.assertTrue(has_another_attribute)
self.assertTrue(len(res1[0]["samaccountname"]) == 1)
- self.assertEquals(str(res1[0]["samaccountname"][0]), "parentguidtest")
+ self.assertEqual(str(res1[0]["samaccountname"][0]), "parentguidtest")
# Testing parentGUID behaviour on rename\
res2 = ldb.search(base="cn=parentguidtest,cn=testotherusers," + self.base_dn,
scope=SCOPE_BASE,
attrs=["parentGUID"])
- self.assertEquals(res1[0]["objectGUID"], res2[0]["parentGUID"])
+ self.assertEqual(res1[0]["objectGUID"], res2[0]["parentGUID"])
delete_force(self.ldb, "cn=parentguidtest,cn=testotherusers," + self.base_dn)
delete_force(self.ldb, "cn=testotherusers," + self.base_dn)
res2 = ldb.search(base=self.base_dn, scope=SCOPE_SUBTREE,
attrs=["groupType"], expression="groupType=-2147483643")
- self.assertEquals(len(res1), len(res2))
+ self.assertEqual(len(res1), len(res2))
self.assertTrue(res1.count > 0)
- self.assertEquals(str(res1[0]["groupType"][0]), "-2147483643")
+ self.assertEqual(str(res1[0]["groupType"][0]), "-2147483643")
def test_linked_attributes(self):
"""This tests the linked attribute behaviour"""
"memberOf": "cn=ldaptestgroup,cn=users," + self.base_dn})
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
ldb.add({
"dn": "cn=ldaptestuser,cn=users," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
"""Test Well known GUID behaviours (including DN+Binary)"""
res = self.ldb.search(base=("<WKGUID=ab1d30f3768811d1aded00c04fd8d5cd,%s>" % self.base_dn), scope=SCOPE_BASE, attrs=[])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=B:32:ab1d30f3768811d1aded00c04fd8d5cd:%s" % res[0].dn))
- self.assertEquals(len(res2), 1)
+ self.assertEqual(len(res2), 1)
# Prove that the matching rule is over the whole DN+Binary
res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=B:32:ab1d30f3768811d1aded00c04fd8d5cd"))
- self.assertEquals(len(res2), 0)
+ self.assertEqual(len(res2), 0)
# Prove that the matching rule is over the whole DN+Binary
res2 = self.ldb.search(scope=SCOPE_BASE, attrs=["wellKnownObjects"], expression=("wellKnownObjects=%s") % res[0].dn)
- self.assertEquals(len(res2), 0)
+ self.assertEqual(len(res2), 0)
def test_subschemasubentry(self):
"""Test subSchemaSubEntry appears when requested, but not when not requested"""
res = self.ldb.search(base=self.base_dn, scope=SCOPE_BASE, attrs=["subSchemaSubEntry"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["subSchemaSubEntry"][0]), "CN=Aggregate," + self.schema_dn)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["subSchemaSubEntry"][0]), "CN=Aggregate," + self.schema_dn)
res = self.ldb.search(base=self.base_dn, scope=SCOPE_BASE, attrs=["*"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertTrue("subScheamSubEntry" not in res[0])
def test_all(self):
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_DN_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_DN_SYNTAX)
try:
ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
ldb.add({"dn": "cn=ldaptestcomputer3,cn=computers," + self.base_dn,
"objectClass": "computer",
# Testing ldb.search for (&(cn=ldaptestcomputer3)(objectClass=user))
res = ldb.search(self.base_dn, expression="(&(cn=ldaptestcomputer3)(objectClass=user))")
- self.assertEquals(len(res), 1, "Found only %d for (&(cn=ldaptestcomputer3)(objectClass=user))" % len(res))
-
- self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer3,CN=Computers," + self.base_dn))
- self.assertEquals(str(res[0]["cn"][0]), "ldaptestcomputer3")
- self.assertEquals(str(res[0]["name"][0]), "ldaptestcomputer3")
- self.assertEquals(str(res[0]["objectClass"][0]), "top")
- self.assertEquals(str(res[0]["objectClass"][1]), "person")
- self.assertEquals(str(res[0]["objectClass"][2]), "organizationalPerson")
- self.assertEquals(str(res[0]["objectClass"][3]), "user")
- self.assertEquals(str(res[0]["objectClass"][4]), "computer")
+ self.assertEqual(len(res), 1, "Found only %d for (&(cn=ldaptestcomputer3)(objectClass=user))" % len(res))
+
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestcomputer3,CN=Computers," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"][0]), "ldaptestcomputer3")
+ self.assertEqual(str(res[0]["name"][0]), "ldaptestcomputer3")
+ self.assertEqual(str(res[0]["objectClass"][0]), "top")
+ self.assertEqual(str(res[0]["objectClass"][1]), "person")
+ self.assertEqual(str(res[0]["objectClass"][2]), "organizationalPerson")
+ self.assertEqual(str(res[0]["objectClass"][3]), "user")
+ self.assertEqual(str(res[0]["objectClass"][4]), "computer")
self.assertTrue("objectGUID" in res[0])
self.assertTrue("whenCreated" in res[0])
- self.assertEquals(str(res[0]["objectCategory"][0]), ("CN=Computer,%s" % ldb.get_schema_basedn()))
- self.assertEquals(int(res[0]["primaryGroupID"][0]), 513)
- self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
- self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
+ self.assertEqual(str(res[0]["objectCategory"][0]), ("CN=Computer,%s" % ldb.get_schema_basedn()))
+ self.assertEqual(int(res[0]["primaryGroupID"][0]), 513)
+ self.assertEqual(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
+ self.assertEqual(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
delete_force(self.ldb, "cn=ldaptestcomputer3,cn=computers," + self.base_dn)
self.fail()
except LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
ldb.modify_ldif("""
dn: cn=ldaptest2computer,cn=computers,""" + self.base_dn + """
self.fail()
except LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
# Testing ranged results
ldb.modify_ldif("""
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE,
attrs=["servicePrincipalName;range=0-*"])
- self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
- self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
+ self.assertEqual(len(res), 1, "Could not find (cn=ldaptest2computer)")
+ self.assertEqual(len(res[0]["servicePrincipalName;range=0-*"]), 30)
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-19"])
- self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
- self.assertEquals(len(res[0]["servicePrincipalName;range=0-19"]), 20)
+ self.assertEqual(len(res), 1, "Could not find (cn=ldaptest2computer)")
+ self.assertEqual(len(res[0]["servicePrincipalName;range=0-19"]), 20)
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-30"])
- self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
- self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
+ self.assertEqual(len(res), 1, "Could not find (cn=ldaptest2computer)")
+ self.assertEqual(len(res[0]["servicePrincipalName;range=0-*"]), 30)
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=0-40"])
- self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
- self.assertEquals(len(res[0]["servicePrincipalName;range=0-*"]), 30)
+ self.assertEqual(len(res), 1, "Could not find (cn=ldaptest2computer)")
+ self.assertEqual(len(res[0]["servicePrincipalName;range=0-*"]), 30)
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=30-40"])
- self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
- self.assertEquals(len(res[0]["servicePrincipalName;range=30-*"]), 0)
+ self.assertEqual(len(res), 1, "Could not find (cn=ldaptest2computer)")
+ self.assertEqual(len(res[0]["servicePrincipalName;range=30-*"]), 0)
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=10-40"])
- self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
- self.assertEquals(len(res[0]["servicePrincipalName;range=10-*"]), 20)
+ self.assertEqual(len(res), 1, "Could not find (cn=ldaptest2computer)")
+ self.assertEqual(len(res[0]["servicePrincipalName;range=10-*"]), 20)
# pos_11 = res[0]["servicePrincipalName;range=10-*"][18]
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-40"])
- self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
- self.assertEquals(len(res[0]["servicePrincipalName;range=11-*"]), 19)
- # self.assertEquals((res[0]["servicePrincipalName;range=11-*"][18]), pos_11)
+ self.assertEqual(len(res), 1, "Could not find (cn=ldaptest2computer)")
+ self.assertEqual(len(res[0]["servicePrincipalName;range=11-*"]), 19)
+ # self.assertEqual((res[0]["servicePrincipalName;range=11-*"][18]), pos_11)
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName;range=11-15"])
- self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
- self.assertEquals(len(res[0]["servicePrincipalName;range=11-15"]), 5)
- # self.assertEquals(res[0]["servicePrincipalName;range=11-15"][4], pos_11)
+ self.assertEqual(len(res), 1, "Could not find (cn=ldaptest2computer)")
+ self.assertEqual(len(res[0]["servicePrincipalName;range=11-15"]), 5)
+ # self.assertEqual(res[0]["servicePrincipalName;range=11-15"][4], pos_11)
res = ldb.search(self.base_dn, expression="(cn=ldaptest2computer))", scope=SCOPE_SUBTREE, attrs=["servicePrincipalName"])
- self.assertEquals(len(res), 1, "Could not find (cn=ldaptest2computer)")
- self.assertEquals(len(res[0]["servicePrincipalName"]), 30)
- # self.assertEquals(res[0]["servicePrincipalName"][18], pos_11)
+ self.assertEqual(len(res), 1, "Could not find (cn=ldaptest2computer)")
+ self.assertEqual(len(res[0]["servicePrincipalName"]), 30)
+ # self.assertEqual(res[0]["servicePrincipalName"][18], pos_11)
delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
ldb.add({
# Testing Ambigious Name Resolution
# Testing ldb.search for (&(anr=ldap testy)(objectClass=user))
res = ldb.search(expression="(&(anr=ldap testy)(objectClass=user))")
- self.assertEquals(len(res), 3, "Found only %d of 3 for (&(anr=ldap testy)(objectClass=user))" % len(res))
+ self.assertEqual(len(res), 3, "Found only %d of 3 for (&(anr=ldap testy)(objectClass=user))" % len(res))
# Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
- self.assertEquals(len(res), 2, "Found only %d of 2 for (&(anr=testy ldap)(objectClass=user))" % len(res))
+ self.assertEqual(len(res), 2, "Found only %d of 2 for (&(anr=testy ldap)(objectClass=user))" % len(res))
# Testing ldb.search for (&(anr=ldap)(objectClass=user))
res = ldb.search(expression="(&(anr=ldap)(objectClass=user))")
- self.assertEquals(len(res), 4, "Found only %d of 4 for (&(anr=ldap)(objectClass=user))" % len(res))
+ self.assertEqual(len(res), 4, "Found only %d of 4 for (&(anr=ldap)(objectClass=user))" % len(res))
# Testing ldb.search for (&(anr==ldap)(objectClass=user))
res = ldb.search(expression="(&(anr==ldap)(objectClass=user))")
- self.assertEquals(len(res), 1, "Could not find (&(anr==ldap)(objectClass=user)). Found only %d for (&(anr=ldap)(objectClass=user))" % len(res))
+ self.assertEqual(len(res), 1, "Could not find (&(anr==ldap)(objectClass=user)). Found only %d for (&(anr=ldap)(objectClass=user))" % len(res))
- self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
- self.assertEquals(str(res[0]["cn"][0]), "ldaptestuser")
- self.assertEquals(str(res[0]["name"]), "ldaptestuser")
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"][0]), "ldaptestuser")
+ self.assertEqual(str(res[0]["name"]), "ldaptestuser")
# Testing ldb.search for (&(anr=testy)(objectClass=user))
res = ldb.search(expression="(&(anr=testy)(objectClass=user))")
- self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy)(objectClass=user))" % len(res))
+ self.assertEqual(len(res), 2, "Found only %d for (&(anr=testy)(objectClass=user))" % len(res))
# Testing ldb.search for (&(anr=testy ldap)(objectClass=user))
res = ldb.search(expression="(&(anr=testy ldap)(objectClass=user))")
- self.assertEquals(len(res), 2, "Found only %d for (&(anr=testy ldap)(objectClass=user))" % len(res))
+ self.assertEqual(len(res), 2, "Found only %d for (&(anr=testy ldap)(objectClass=user))" % len(res))
# Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
# this test disabled for the moment, as anr with == tests are not understood
# res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
-# self.assertEquals(len(res), 1, "Found only %d for (&(anr==testy ldap)(objectClass=user))" % len(res))
+# self.assertEqual(len(res), 1, "Found only %d for (&(anr==testy ldap)(objectClass=user))" % len(res))
-# self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
-# self.assertEquals(res[0]["cn"][0], "ldaptestuser")
-# self.assertEquals(res[0]["name"][0], "ldaptestuser")
+# self.assertEqual(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
+# self.assertEqual(res[0]["cn"][0], "ldaptestuser")
+# self.assertEqual(res[0]["name"][0], "ldaptestuser")
# Testing ldb.search for (&(anr==testy ldap)(objectClass=user))
# res = ldb.search(expression="(&(anr==testy ldap)(objectClass=user))")
-# self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap)(objectClass=user))")
+# self.assertEqual(len(res), 1, "Could not find (&(anr==testy ldap)(objectClass=user))")
-# self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
-# self.assertEquals(res[0]["cn"][0], "ldaptestuser")
-# self.assertEquals(res[0]["name"][0], "ldaptestuser")
+# self.assertEqual(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
+# self.assertEqual(res[0]["cn"][0], "ldaptestuser")
+# self.assertEqual(res[0]["name"][0], "ldaptestuser")
# Testing ldb.search for (&(anr=testy ldap user)(objectClass=user))
res = ldb.search(expression="(&(anr=testy ldap user)(objectClass=user))")
- self.assertEquals(len(res), 1, "Could not find (&(anr=testy ldap user)(objectClass=user))")
+ self.assertEqual(len(res), 1, "Could not find (&(anr=testy ldap user)(objectClass=user))")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
- self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
- self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"]), "ldaptestuser2")
+ self.assertEqual(str(res[0]["name"]), "ldaptestuser2")
# Testing ldb.search for (&(anr==testy ldap user2)(objectClass=user))
# res = ldb.search(expression="(&(anr==testy ldap user2)(objectClass=user))")
-# self.assertEquals(len(res), 1, "Could not find (&(anr==testy ldap user2)(objectClass=user))")
+# self.assertEqual(len(res), 1, "Could not find (&(anr==testy ldap user2)(objectClass=user))")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
- self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
- self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"]), "ldaptestuser2")
+ self.assertEqual(str(res[0]["name"]), "ldaptestuser2")
# Testing ldb.search for (&(anr==ldap user2)(objectClass=user))
# res = ldb.search(expression="(&(anr==ldap user2)(objectClass=user))")
-# self.assertEquals(len(res), 1, "Could not find (&(anr==ldap user2)(objectClass=user))")
+# self.assertEqual(len(res), 1, "Could not find (&(anr==ldap user2)(objectClass=user))")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
- self.assertEquals(str(res[0]["cn"]), "ldaptestuser2")
- self.assertEquals(str(res[0]["name"]), "ldaptestuser2")
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"]), "ldaptestuser2")
+ self.assertEqual(str(res[0]["name"]), "ldaptestuser2")
# Testing ldb.search for (&(anr==not ldap user2)(objectClass=user))
# res = ldb.search(expression="(&(anr==not ldap user2)(objectClass=user))")
-# self.assertEquals(len(res), 0, "Must not find (&(anr==not ldap user2)(objectClass=user))")
+# self.assertEqual(len(res), 0, "Must not find (&(anr==not ldap user2)(objectClass=user))")
# Testing ldb.search for (&(anr=not ldap user2)(objectClass=user))
res = ldb.search(expression="(&(anr=not ldap user2)(objectClass=user))")
- self.assertEquals(len(res), 0, "Must not find (&(anr=not ldap user2)(objectClass=user))")
+ self.assertEqual(len(res), 0, "Must not find (&(anr=not ldap user2)(objectClass=user))")
# Testing ldb.search for (&(anr="testy ldap")(objectClass=user)) (ie, with quotes)
# res = ldb.search(expression="(&(anr==\"testy ldap\")(objectClass=user))")
-# self.assertEquals(len(res), 0, "Found (&(anr==\"testy ldap\")(objectClass=user))")
+# self.assertEqual(len(res), 0, "Found (&(anr==\"testy ldap\")(objectClass=user))")
# Testing Renames
attrs = ["objectGUID", "objectSid"]
# Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))
res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
- self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
+ self.assertEqual(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
# Check rename works with extended/alternate DN forms
ldb.rename("<SID=" + get_string(ldb.schema_format_value("objectSID", res_user[0]["objectSID"][0])) + ">", "cn=ldaptestUSER3,cn=users," + self.base_dn)
# Testing ldb.search for (&(cn=ldaptestuser3)(objectClass=user))
res = ldb.search(expression="(&(cn=ldaptestuser3)(objectClass=user))")
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser3)(objectClass=user))")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestuser3)(objectClass=user))")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
- self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
- self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"]), "ldaptestUSER3")
+ self.assertEqual(str(res[0]["name"]), "ldaptestUSER3")
#"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))"
res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
- self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
+ self.assertEqual(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=*))(objectClass=user))")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
- self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
- self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"]), "ldaptestUSER3")
+ self.assertEqual(str(res[0]["name"]), "ldaptestUSER3")
#"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))"
res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
- self.assertEquals(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
+ self.assertEqual(len(res), 1, "(&(&(cn=ldaptestuser3)(userAccountControl=546))(objectClass=user))")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
- self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
- self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"]), "ldaptestUSER3")
+ self.assertEqual(str(res[0]["name"]), "ldaptestUSER3")
#"Testing ldb.search for (&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))"
res = ldb.search(expression="(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
- self.assertEquals(len(res), 0, "(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
+ self.assertEqual(len(res), 0, "(&(&(cn=ldaptestuser3)(userAccountControl=547))(objectClass=user))")
# Testing ldb.search for (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ") - should not work
res = ldb.search(expression="(dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
- self.assertEquals(len(res), 0, "Could find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
+ self.assertEqual(len(res), 0, "Could find (dn=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
# Testing ldb.search for (distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")
res = ldb.search(expression="(distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
- self.assertEquals(len(res), 1, "Could not find (distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
- self.assertEquals(str(res[0]["cn"]), "ldaptestUSER3")
- self.assertEquals(str(res[0]["name"]), "ldaptestUSER3")
+ self.assertEqual(len(res), 1, "Could not find (distinguishedName=CN=ldaptestUSER3,CN=Users," + self.base_dn + ")")
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestUSER3,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"]), "ldaptestUSER3")
+ self.assertEqual(str(res[0]["name"]), "ldaptestUSER3")
# ensure we cannot add it again
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# rename back
ldb.rename("cn=ldaptestuser3,cn=users," + self.base_dn, "cn=ldaptestuser2,cn=users," + self.base_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
# ensure can now use that name
ldb.add({"dn": "cn=ldaptestuser3,cn=users," + self.base_dn,
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
try:
ldb.rename("cn=ldaptestuser3,cn=users,%s" % self.base_dn, "cn=ldaptestuser3,%s" % ldb.get_config_basedn())
self.fail()
# Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user))
res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))")
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user))")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user))")
# Testing subtree ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
try:
self.fail(res)
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
# Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in (just renamed from) cn=ldaptestcontainer," + self.base_dn
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
# Testing ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in renamed container"
res = ldb.search("cn=ldaptestcontainer2," + self.base_dn, expression="(&(cn=ldaptestuser4)(objectClass=user))", scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + self.base_dn)
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestuser4)(objectClass=user)) under cn=ldaptestcontainer2," + self.base_dn)
- self.assertEquals(str(res[0].dn), ("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn))
- self.assertEquals(str(res[0]["memberOf"][0]).upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn))
+ self.assertEqual(str(res[0]["memberOf"][0]).upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
time.sleep(4)
# Testing ldb.search for (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)) to check subtree renames and linked attributes"
res = ldb.search(self.base_dn, expression="(&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group))", scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 1, "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)), perhaps linked attributes are not consistant with subtree renames?")
+ self.assertEqual(len(res), 1, "Could not find (&(member=CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn + ")(objectclass=group)), perhaps linked attributes are not consistant with subtree renames?")
# Testing ldb.rename (into itself) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer2," + self.base_dn
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Testing ldb.rename (into non-existent container) of cn=ldaptestcontainer2," + self.base_dn + " to cn=ldaptestcontainer,cn=ldaptestcontainer3," + self.base_dn
try:
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
+ self.assertEqual(num, ERR_NOT_ALLOWED_ON_NON_LEAF)
# Testing base ldb.search for CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn
res = ldb.search(expression="(objectclass=*)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
res = ldb.search(expression="(cn=ldaptestuser40)", base=("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn), scope=SCOPE_BASE)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_ONELEVEL)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
# Testing one-level ldb.search for (&(cn=ldaptestuser4)(objectClass=user)) in cn=ldaptestcontainer2," + self.base_dn
res = ldb.search(expression="(&(cn=ldaptestuser4)(objectClass=user))", base=("cn=ldaptestcontainer2," + self.base_dn), scope=SCOPE_SUBTREE)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
# Testing delete of subtree renamed "+("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn)
ldb.delete(("CN=ldaptestuser4,CN=ldaptestcontainer2," + self.base_dn))
# Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))"
res = ldb.search(expression="(&(cn=ldaptestuser)(objectClass=user))")
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
- self.assertEquals(str(res[0]["cn"]), "ldaptestuser")
- self.assertEquals(str(res[0]["name"]), "ldaptestuser")
- self.assertEquals(set(res[0]["objectClass"]), set([b"top", b"person", b"organizationalPerson", b"user"]))
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestuser,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"]), "ldaptestuser")
+ self.assertEqual(str(res[0]["name"]), "ldaptestuser")
+ self.assertEqual(set(res[0]["objectClass"]), set([b"top", b"person", b"organizationalPerson", b"user"]))
self.assertTrue("objectGUID" in res[0])
self.assertTrue("whenCreated" in res[0])
- self.assertEquals(str(res[0]["objectCategory"]), ("CN=Person,%s" % ldb.get_schema_basedn()))
- self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
- self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
- self.assertEquals(str(res[0]["memberOf"][0]).upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
- self.assertEquals(len(res[0]["memberOf"]), 1)
+ self.assertEqual(str(res[0]["objectCategory"]), ("CN=Person,%s" % ldb.get_schema_basedn()))
+ self.assertEqual(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
+ self.assertEqual(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
+ self.assertEqual(str(res[0]["memberOf"][0]).upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
+ self.assertEqual(len(res[0]["memberOf"]), 1)
# Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,%s))" % ldb.get_schema_basedn()
res2 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=cn=person,%s))" % ldb.get_schema_basedn())
- self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,%s))" % ldb.get_schema_basedn())
+ self.assertEqual(len(res2), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,%s))" % ldb.get_schema_basedn())
- self.assertEquals(res[0].dn, res2[0].dn)
+ self.assertEqual(res[0].dn, res2[0].dn)
# Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))"
res3 = ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
- self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched %d" % len(res3))
+ self.assertEqual(len(res3), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)): matched %d" % len(res3))
- self.assertEquals(res[0].dn, res3[0].dn)
+ self.assertEqual(res[0].dn, res3[0].dn)
if gc_ldb is not None:
# Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog"
res3gc = gc_ldb.search(expression="(&(cn=ldaptestuser)(objectCategory=PerSon))")
- self.assertEquals(len(res3gc), 1)
+ self.assertEqual(len(res3gc), 1)
- self.assertEquals(res[0].dn, res3gc[0].dn)
+ self.assertEqual(res[0].dn, res3gc[0].dn)
# Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in with 'phantom root' control"
if gc_ldb is not None:
res3control = gc_ldb.search(self.base_dn, expression="(&(cn=ldaptestuser)(objectCategory=PerSon))", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
- self.assertEquals(len(res3control), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog")
+ self.assertEqual(len(res3control), 1, "Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog")
- self.assertEquals(res[0].dn, res3control[0].dn)
+ self.assertEqual(res[0].dn, res3control[0].dn)
ldb.delete(res[0].dn)
# Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))"
res = ldb.search(expression="(&(cn=ldaptestcomputer)(objectClass=user))")
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestuser)(objectClass=user))")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestcomputer,CN=Computers," + self.base_dn))
- self.assertEquals(str(res[0]["cn"]), "ldaptestcomputer")
- self.assertEquals(str(res[0]["name"]), "ldaptestcomputer")
- self.assertEquals(set(res[0]["objectClass"]), set([b"top", b"person", b"organizationalPerson", b"user", b"computer"]))
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestcomputer,CN=Computers," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"]), "ldaptestcomputer")
+ self.assertEqual(str(res[0]["name"]), "ldaptestcomputer")
+ self.assertEqual(set(res[0]["objectClass"]), set([b"top", b"person", b"organizationalPerson", b"user", b"computer"]))
self.assertTrue("objectGUID" in res[0])
self.assertTrue("whenCreated" in res[0])
- self.assertEquals(str(res[0]["objectCategory"]), ("CN=Computer,%s" % ldb.get_schema_basedn()))
- self.assertEquals(int(res[0]["primaryGroupID"][0]), 513)
- self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
- self.assertEquals(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
- self.assertEquals(str(res[0]["memberOf"][0]).upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
- self.assertEquals(len(res[0]["memberOf"]), 1)
+ self.assertEqual(str(res[0]["objectCategory"]), ("CN=Computer,%s" % ldb.get_schema_basedn()))
+ self.assertEqual(int(res[0]["primaryGroupID"][0]), 513)
+ self.assertEqual(int(res[0]["sAMAccountType"][0]), ATYPE_NORMAL_ACCOUNT)
+ self.assertEqual(int(res[0]["userAccountControl"][0]), UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
+ self.assertEqual(str(res[0]["memberOf"][0]).upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
+ self.assertEqual(len(res[0]["memberOf"]), 1)
# Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % ldb.get_schema_basedn()
res2 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % ldb.get_schema_basedn())
- self.assertEquals(len(res2), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % ldb.get_schema_basedn())
+ self.assertEqual(len(res2), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % ldb.get_schema_basedn())
- self.assertEquals(res[0].dn, res2[0].dn)
+ self.assertEqual(res[0].dn, res2[0].dn)
if gc_ldb is not None:
# Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s)) in Global Catalog" % gc_ldb.get_schema_basedn()
res2gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s))" % gc_ldb.get_schema_basedn())
- self.assertEquals(len(res2gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s)) In Global Catalog" % gc_ldb.get_schema_basedn())
+ self.assertEqual(len(res2gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,%s)) In Global Catalog" % gc_ldb.get_schema_basedn())
- self.assertEquals(res[0].dn, res2gc[0].dn)
+ self.assertEqual(res[0].dn, res2gc[0].dn)
# Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))"
res3 = ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
- self.assertEquals(len(res3), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))")
+ self.assertEqual(len(res3), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))")
- self.assertEquals(res[0].dn, res3[0].dn)
+ self.assertEqual(res[0].dn, res3[0].dn)
if gc_ldb is not None:
# Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog"
res3gc = gc_ldb.search(expression="(&(cn=ldaptestcomputer)(objectCategory=compuTER))")
- self.assertEquals(len(res3gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog")
+ self.assertEqual(len(res3gc), 1, "Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog")
- self.assertEquals(res[0].dn, res3gc[0].dn)
+ self.assertEqual(res[0].dn, res3gc[0].dn)
# Testing ldb.search for (&(cn=ldaptestcomp*r)(objectCategory=compuTER))"
res4 = ldb.search(expression="(&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
- self.assertEquals(len(res4), 1, "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
+ self.assertEqual(len(res4), 1, "Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))")
- self.assertEquals(res[0].dn, res4[0].dn)
+ self.assertEqual(res[0].dn, res4[0].dn)
# Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))"
res5 = ldb.search(expression="(&(cn=ldaptestcomput*)(objectCategory=compuTER))")
- self.assertEquals(len(res5), 1, "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))")
+ self.assertEqual(len(res5), 1, "Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))")
- self.assertEquals(res[0].dn, res5[0].dn)
+ self.assertEqual(res[0].dn, res5[0].dn)
# Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))"
res6 = ldb.search(expression="(&(cn=*daptestcomputer)(objectCategory=compuTER))")
- self.assertEquals(len(res6), 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))")
+ self.assertEqual(len(res6), 1, "Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))")
- self.assertEquals(res[0].dn, res6[0].dn)
+ self.assertEqual(res[0].dn, res6[0].dn)
ldb.delete("<GUID=" + get_string(ldb.schema_format_value("objectGUID", res[0]["objectGUID"][0])) + ">")
# Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))"
res = ldb.search(expression="(&(cn=ldaptest2computer)(objectClass=user))")
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptest2computer)(objectClass=user))")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptest2computer)(objectClass=user))")
- self.assertEquals(str(res[0].dn), "CN=ldaptest2computer,CN=Computers," + self.base_dn)
- self.assertEquals(str(res[0]["cn"]), "ldaptest2computer")
- self.assertEquals(str(res[0]["name"]), "ldaptest2computer")
- self.assertEquals(list(res[0]["objectClass"]), [b"top", b"person", b"organizationalPerson", b"user", b"computer"])
+ self.assertEqual(str(res[0].dn), "CN=ldaptest2computer,CN=Computers," + self.base_dn)
+ self.assertEqual(str(res[0]["cn"]), "ldaptest2computer")
+ self.assertEqual(str(res[0]["name"]), "ldaptest2computer")
+ self.assertEqual(list(res[0]["objectClass"]), [b"top", b"person", b"organizationalPerson", b"user", b"computer"])
self.assertTrue("objectGUID" in res[0])
self.assertTrue("whenCreated" in res[0])
- self.assertEquals(str(res[0]["objectCategory"][0]), "CN=Computer,%s" % ldb.get_schema_basedn())
- self.assertEquals(int(res[0]["sAMAccountType"][0]), ATYPE_WORKSTATION_TRUST)
- self.assertEquals(int(res[0]["userAccountControl"][0]), UF_WORKSTATION_TRUST_ACCOUNT)
+ self.assertEqual(str(res[0]["objectCategory"][0]), "CN=Computer,%s" % ldb.get_schema_basedn())
+ self.assertEqual(int(res[0]["sAMAccountType"][0]), ATYPE_WORKSTATION_TRUST)
+ self.assertEqual(int(res[0]["userAccountControl"][0]), UF_WORKSTATION_TRUST_ACCOUNT)
ldb.delete("<SID=" + get_string(ldb.schema_format_value("objectSID", res[0]["objectSID"][0])) + ">")
attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "memberOf", "allowedAttributes", "allowedAttributesEffective"]
# Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))"
res_user = ldb.search(self.base_dn, expression="(&(cn=ldaptestUSer2)(objectClass=user))", scope=SCOPE_SUBTREE, attrs=attrs)
- self.assertEquals(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
+ self.assertEqual(len(res_user), 1, "Could not find (&(cn=ldaptestUSer2)(objectClass=user))")
- self.assertEquals(str(res_user[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
- self.assertEquals(str(res_user[0]["cn"]), "ldaptestuser2")
- self.assertEquals(str(res_user[0]["name"]), "ldaptestuser2")
- self.assertEquals(list(res_user[0]["objectClass"]), [b"top", b"person", b"organizationalPerson", b"user"])
+ self.assertEqual(str(res_user[0].dn), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
+ self.assertEqual(str(res_user[0]["cn"]), "ldaptestuser2")
+ self.assertEqual(str(res_user[0]["name"]), "ldaptestuser2")
+ self.assertEqual(list(res_user[0]["objectClass"]), [b"top", b"person", b"organizationalPerson", b"user"])
self.assertTrue("objectSid" in res_user[0])
self.assertTrue("objectGUID" in res_user[0])
self.assertTrue("whenCreated" in res_user[0])
self.assertTrue("nTSecurityDescriptor" in res_user[0])
self.assertTrue("allowedAttributes" in res_user[0])
self.assertTrue("allowedAttributesEffective" in res_user[0])
- self.assertEquals(str(res_user[0]["memberOf"][0]).upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
+ self.assertEqual(str(res_user[0]["memberOf"][0]).upper(), ("CN=ldaptestgroup2,CN=Users," + self.base_dn).upper())
ldaptestuser2_sid = res_user[0]["objectSid"][0]
ldaptestuser2_guid = res_user[0]["objectGUID"][0]
attrs = ["cn", "name", "objectClass", "objectGUID", "objectSID", "whenCreated", "nTSecurityDescriptor", "member", "allowedAttributes", "allowedAttributesEffective"]
# Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group))"
res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
- self.assertEquals(str(res[0]["cn"]), "ldaptestgroup2")
- self.assertEquals(str(res[0]["name"]), "ldaptestgroup2")
- self.assertEquals(list(res[0]["objectClass"]), [b"top", b"group"])
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"]), "ldaptestgroup2")
+ self.assertEqual(str(res[0]["name"]), "ldaptestgroup2")
+ self.assertEqual(list(res[0]["objectClass"]), [b"top", b"group"])
self.assertTrue("objectGUID" in res[0])
self.assertTrue("objectSid" in res[0])
self.assertTrue("whenCreated" in res[0])
self.assertTrue(("CN=ldaptestuser2,CN=Users," + self.base_dn).upper() in memberUP)
res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs, controls=["extended_dn:1:1"])
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
print(res[0]["member"])
memberUP = []
""")
res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group))")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
- self.assertEquals(str(res[0]["member"][0]), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
- self.assertEquals(len(res[0]["member"]), 1)
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0]["member"][0]), ("CN=ldaptestuser2,CN=Users," + self.base_dn))
+ self.assertEqual(len(res[0]["member"]), 1)
ldb.delete(("CN=ldaptestuser2,CN=Users," + self.base_dn))
attrs = ["cn", "name", "objectClass", "objectGUID", "whenCreated", "nTSecurityDescriptor", "member"]
# Testing ldb.search for (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete"
res = ldb.search(self.base_dn, expression="(&(cn=ldaptestgroup2)(objectClass=group))", scope=SCOPE_SUBTREE, attrs=attrs)
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestgroup2)(objectClass=group)) to check linked delete")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestgroup2,CN=Users," + self.base_dn))
self.assertTrue("member" not in res[0])
# Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))"
res = ldb.search(expression="(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
res = ldb.search(expression="(&(cn=ldaptestutf8user èùéìòà)(objectclass=user))")
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))")
- self.assertEquals(str(res[0].dn), ("CN=ldaptestutf8user èùéìòà,CN=Users," + self.base_dn))
- self.assertEquals(str(res[0]["cn"]), "ldaptestutf8user èùéìòà")
- self.assertEquals(str(res[0]["name"]), "ldaptestutf8user èùéìòà")
- self.assertEquals(list(res[0]["objectClass"]), [b"top", b"person", b"organizationalPerson", b"user"])
+ self.assertEqual(str(res[0].dn), ("CN=ldaptestutf8user èùéìòà,CN=Users," + self.base_dn))
+ self.assertEqual(str(res[0]["cn"]), "ldaptestutf8user èùéìòà")
+ self.assertEqual(str(res[0]["name"]), "ldaptestutf8user èùéìòà")
+ self.assertEqual(list(res[0]["objectClass"]), [b"top", b"person", b"organizationalPerson", b"user"])
self.assertTrue("objectGUID" in res[0])
self.assertTrue("whenCreated" in res[0])
# Testing ldb.search for (&(cn=ldaptestutf8user2*)(objectClass=user))"
res = ldb.search(expression="(&(cn=ldaptestutf8user2*)(objectClass=user))")
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestutf8user2*)(objectClass=user))")
# Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))"
res = ldb.search(expression="(&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))")
- self.assertEquals(len(res), 1, "Could not find (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))")
+ self.assertEqual(len(res), 1, "Could not find (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))")
# delete "ldaptestutf8user2 "
ldb.delete(res[0].dn)
# Testing that we can't get at the configuration DN from the main search base"
res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"])
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# Testing that we can get at the configuration DN from the main search base on the LDAP port with the 'phantom root' search_options control"
res = ldb.search(self.base_dn, expression="objectClass=crossRef", scope=SCOPE_SUBTREE, attrs=["cn"], controls=["search_options:1:2"])
# Testing objectClass attribute order on "+ self.base_dn
res = ldb.search(expression="objectClass=domain", base=self.base_dn,
scope=SCOPE_BASE, attrs=["objectClass"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
- self.assertEquals(list(res[0]["objectClass"]), [b"top", b"domain", b"domainDNS"])
+ self.assertEqual(list(res[0]["objectClass"]), [b"top", b"domain", b"domainDNS"])
# check enumeration
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
finally:
delete_force(self.ldb, user_dn)
#
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
m.dn = Dn(ldb, user_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, user_dn)
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, user_dn)
#
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
dshstr = dshstr + str(i)
else:
# There does not seem to be an upper limit
self.ldb.set_dsheuristics(dshstr + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
# apart from the above, all char values are accepted
self.ldb.set_dsheuristics("123ABC-+!1asdfg@#^")
- self.assertEquals(self.ldb.get_dsheuristics(), b"123ABC-+!1asdfg@#^")
+ self.assertEqual(self.ldb.get_dsheuristics(), b"123ABC-+!1asdfg@#^")
finally:
# restore old value
self.ldb.set_dsheuristics(dsheuristics)
really return something"""
res = self.ldb.search(attrs=["cn"],
controls=["paged_results:1:10"])
- self.assertEquals(len(res.controls), 1)
- self.assertEquals(res.controls[0].oid, "1.2.840.113556.1.4.319")
+ self.assertEqual(len(res.controls), 1)
+ self.assertEqual(res.controls[0].oid, "1.2.840.113556.1.4.319")
s = str(res.controls[0])
def test_operational(self):
attrs=["createTimeStamp", "modifyTimeStamp",
"structuralObjectClass", "whenCreated",
"whenChanged"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertTrue("createTimeStamp" in res[0])
self.assertTrue("modifyTimeStamp" in res[0])
self.assertTrue("structuralObjectClass" in res[0])
self.assertTrue(len(res) == 1)
self.assertTrue("msTSExpireDate" in res[0])
self.assertTrue(len(res[0]["msTSExpireDate"]) == 1)
- self.assertEquals(str(res[0]["msTSExpireDate"][0]), v_get)
+ self.assertEqual(str(res[0]["msTSExpireDate"][0]), v_get)
def test_ldapSearchNoAttributes(self):
"""Testing ldap search with no attributes"""
def test_rootdse_attrs(self):
"""Testing for all rootDSE attributes"""
res = self.ldb.search("", scope=SCOPE_BASE, attrs=[])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
def test_highestcommittedusn(self):
"""Testing for highestCommittedUSN"""
res = self.ldb.search("", scope=SCOPE_BASE, attrs=["highestCommittedUSN"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertTrue(int(res[0]["highestCommittedUSN"][0]) != 0)
def test_netlogon(self):
"""Testing for netlogon via LDAP"""
res = self.ldb.search("", scope=SCOPE_BASE, attrs=["netlogon"])
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
def test_netlogon_highestcommitted_usn(self):
"""Testing for netlogon and highestCommittedUSN via LDAP"""
res = self.ldb.search("", scope=SCOPE_BASE,
attrs=["netlogon", "highestCommittedUSN"])
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
def test_namingContexts(self):
"""Testing for namingContexts in rootDSE"""
res = self.ldb.search("", scope=SCOPE_BASE,
attrs=["namingContexts", "defaultNamingContext", "schemaNamingContext", "configurationNamingContext"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
ncs = set([])
for nc in res[0]["namingContexts"]:
"""Testing the server paths in rootDSE"""
res = self.ldb.search("", scope=SCOPE_BASE,
attrs=["dsServiceName", "serverName"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertTrue("CN=Servers" in str(res[0]["dsServiceName"][0]))
self.assertTrue("CN=Sites" in str(res[0]["dsServiceName"][0]))
"""Testing the server paths in rootDSE"""
res = self.ldb.search("", scope=SCOPE_BASE,
attrs=["forestFunctionality", "domainFunctionality", "domainControllerFunctionality"])
- self.assertEquals(len(res), 1)
- self.assertEquals(len(res[0]["forestFunctionality"]), 1)
- self.assertEquals(len(res[0]["domainFunctionality"]), 1)
- self.assertEquals(len(res[0]["domainControllerFunctionality"]), 1)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(len(res[0]["forestFunctionality"]), 1)
+ self.assertEqual(len(res[0]["domainFunctionality"]), 1)
+ self.assertEqual(len(res[0]["domainControllerFunctionality"]), 1)
self.assertTrue(int(res[0]["forestFunctionality"][0]) <= int(res[0]["domainFunctionality"][0]))
self.assertTrue(int(res[0]["domainControllerFunctionality"][0]) >= int(res[0]["domainFunctionality"][0]))
res2 = self.ldb.search("", scope=SCOPE_BASE,
attrs=["dsServiceName", "serverName"])
- self.assertEquals(len(res2), 1)
- self.assertEquals(len(res2[0]["dsServiceName"]), 1)
+ self.assertEqual(len(res2), 1)
+ self.assertEqual(len(res2[0]["dsServiceName"]), 1)
res3 = self.ldb.search(res2[0]["dsServiceName"][0], scope=SCOPE_BASE, attrs=["msDS-Behavior-Version"])
- self.assertEquals(len(res3), 1)
- self.assertEquals(len(res3[0]["msDS-Behavior-Version"]), 1)
- self.assertEquals(int(res[0]["domainControllerFunctionality"][0]), int(res3[0]["msDS-Behavior-Version"][0]))
+ self.assertEqual(len(res3), 1)
+ self.assertEqual(len(res3[0]["msDS-Behavior-Version"]), 1)
+ self.assertEqual(int(res[0]["domainControllerFunctionality"][0]), int(res3[0]["msDS-Behavior-Version"][0]))
res4 = self.ldb.search(ldb.domain_dn(), scope=SCOPE_BASE, attrs=["msDS-Behavior-Version"])
- self.assertEquals(len(res4), 1)
- self.assertEquals(len(res4[0]["msDS-Behavior-Version"]), 1)
- self.assertEquals(int(res[0]["domainFunctionality"][0]), int(res4[0]["msDS-Behavior-Version"][0]))
+ self.assertEqual(len(res4), 1)
+ self.assertEqual(len(res4[0]["msDS-Behavior-Version"]), 1)
+ self.assertEqual(int(res[0]["domainFunctionality"][0]), int(res4[0]["msDS-Behavior-Version"][0]))
res5 = self.ldb.search("cn=partitions,%s" % ldb.get_config_basedn(), scope=SCOPE_BASE, attrs=["msDS-Behavior-Version"])
- self.assertEquals(len(res5), 1)
- self.assertEquals(len(res5[0]["msDS-Behavior-Version"]), 1)
- self.assertEquals(int(res[0]["forestFunctionality"][0]), int(res5[0]["msDS-Behavior-Version"][0]))
+ self.assertEqual(len(res5), 1)
+ self.assertEqual(len(res5[0]["msDS-Behavior-Version"]), 1)
+ self.assertEqual(int(res[0]["forestFunctionality"][0]), int(res5[0]["msDS-Behavior-Version"][0]))
def test_dnsHostname(self):
"""Testing the DNS hostname in rootDSE"""
res = self.ldb.search("", scope=SCOPE_BASE,
attrs=["dnsHostName", "serverName"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
res2 = self.ldb.search(res[0]["serverName"][0], scope=SCOPE_BASE,
attrs=["dNSHostName"])
- self.assertEquals(len(res2), 1)
+ self.assertEqual(len(res2), 1)
- self.assertEquals(res[0]["dnsHostName"][0], res2[0]["dNSHostName"][0])
+ self.assertEqual(res[0]["dnsHostName"][0], res2[0]["dNSHostName"][0])
def test_ldapServiceName(self):
"""Testing the ldap service name in rootDSE"""
res = self.ldb.search("", scope=SCOPE_BASE,
attrs=["ldapServiceName", "dnsHostName"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertTrue("ldapServiceName" in res[0])
self.assertTrue("dnsHostName" in res[0])
given = str(res[0]["ldapServiceName"][0])
expected = "%s:%s$@%s" % (dns_domainname.lower(), hostname.lower(), dns_domainname.upper())
- self.assertEquals(given, expected)
+ self.assertEqual(given, expected)
if "://" not in host:
"""Testing we can read the generated schema via LDAP"""
res = self.ldb.search("cn=aggregate," + self.schema_dn, scope=SCOPE_BASE,
attrs=["objectClasses", "attributeTypes", "dITContentRules"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertTrue("dITContentRules" in res[0])
self.assertTrue("objectClasses" in res[0])
self.assertTrue("attributeTypes" in res[0])
# Must keep the "*" form
res = self.ldb.search("cn=aggregate," + self.schema_dn, scope=SCOPE_BASE,
attrs=["*"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertFalse("dITContentRules" in res[0])
self.assertFalse("objectClasses" in res[0])
self.assertFalse("attributeTypes" in res[0])
res = []
res = self.ldb.search("cn=%s,%s" % (attr_name, self.schema_dn), scope=SCOPE_BASE,
attrs=["lDAPDisplayName", "schemaIDGUID", "msDS-IntID"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["lDAPDisplayName"][0]), attr_ldap_display_name)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["lDAPDisplayName"][0]), attr_ldap_display_name)
self.assertTrue("schemaIDGUID" in res[0])
if "msDS-IntId" in res[0]:
msDS_IntId = int(res[0]["msDS-IntId"][0])
self.fail()
except LdbError as e1:
(num, _) = e1.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
ldif = """
dn: CN=%s,%s""" % (class_name, self.schema_dn) + """
res = []
res = self.ldb.search("cn=%s,%s" % (class_name, self.schema_dn), scope=SCOPE_BASE,
attrs=["lDAPDisplayName", "defaultObjectCategory", "schemaIDGUID", "distinguishedName"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["lDAPDisplayName"][0]), class_ldap_display_name)
- self.assertEquals(res[0]["defaultObjectCategory"][0], res[0]["distinguishedName"][0])
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["lDAPDisplayName"][0]), class_ldap_display_name)
+ self.assertEqual(res[0]["defaultObjectCategory"][0], res[0]["distinguishedName"][0])
self.assertTrue("schemaIDGUID" in res[0])
ldif = """
# Search for created object
obj_res = self.ldb.search("cn=%s,cn=Users,%s" % (object_name, self.base_dn), scope=SCOPE_BASE, attrs=["replPropertyMetaData"])
- self.assertEquals(len(obj_res), 1)
+ self.assertEqual(len(obj_res), 1)
self.assertTrue("replPropertyMetaData" in obj_res[0])
val = obj_res[0]["replPropertyMetaData"][0]
repl = ndr_unpack(drsblobs.replPropertyMetaDataBlob, val)
res = self.ldb.search("cn=%s,%s" % (class_name, self.schema_dn), scope=SCOPE_BASE,
attrs=["lDAPDisplayName", "defaultObjectCategory",
"schemaIDGUID", "distinguishedName"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["lDAPDisplayName"][0]), class_ldap_display_name)
- self.assertEquals(res[0]["defaultObjectCategory"][0], res[0]["distinguishedName"][0])
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["lDAPDisplayName"][0]), class_ldap_display_name)
+ self.assertEqual(res[0]["defaultObjectCategory"][0], res[0]["distinguishedName"][0])
self.assertTrue("schemaIDGUID" in res[0])
ldif = """
# Search for created object
res = []
res = self.ldb.search("ou=%s,%s" % (object_name, self.base_dn), scope=SCOPE_BASE, attrs=["dn"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
# Delete the object
delete_force(self.ldb, "ou=%s,%s" % (object_name, self.base_dn))
self.fail("Should have failed to add duplicate attributeID value")
except LdbError as e2:
(enum, estr) = e2.args
- self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(enum, ERR_UNWILLING_TO_PERFORM)
def test_duplicate_attributeID_governsID(self):
"""Testing creating a duplicate attribute and class"""
self.fail("Should have failed to add duplicate governsID conflicting with attributeID value")
except LdbError as e3:
(enum, estr) = e3.args
- self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(enum, ERR_UNWILLING_TO_PERFORM)
def test_duplicate_cn(self):
"""Testing creating a duplicate attribute"""
self.fail("Should have failed to add attribute with duplicate CN")
except LdbError as e4:
(enum, estr) = e4.args
- self.assertEquals(enum, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(enum, ERR_ENTRY_ALREADY_EXISTS)
def test_duplicate_implicit_ldapdisplayname(self):
"""Testing creating a duplicate attribute ldapdisplayname"""
self.fail("Should have failed to add attribute with duplicate of the implicit ldapDisplayName")
except LdbError as e5:
(enum, estr) = e5.args
- self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(enum, ERR_UNWILLING_TO_PERFORM)
def test_duplicate_explicit_ldapdisplayname(self):
"""Testing creating a duplicate attribute ldapdisplayname"""
self.fail("Should have failed to add attribute with duplicate ldapDisplayName")
except LdbError as e6:
(enum, estr) = e6.args
- self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(enum, ERR_UNWILLING_TO_PERFORM)
def test_duplicate_explicit_ldapdisplayname_with_class(self):
"""Testing creating a duplicate attribute ldapdisplayname between
self.fail("Should have failed to add class with duplicate ldapDisplayName")
except LdbError as e7:
(enum, estr) = e7.args
- self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(enum, ERR_UNWILLING_TO_PERFORM)
def test_duplicate_via_rename_ldapdisplayname(self):
"""Testing creating a duplicate attribute ldapdisplayname"""
self.fail("Should have failed to modify schema to have attribute with duplicate ldapDisplayName")
except LdbError as e8:
(enum, estr) = e8.args
- self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(enum, ERR_UNWILLING_TO_PERFORM)
def test_duplicate_via_rename_attributeID(self):
"""Testing creating a duplicate attributeID"""
self.fail("Should have failed to modify schema to have attribute with duplicate attributeID")
except LdbError as e9:
(enum, estr) = e9.args
- self.assertEquals(enum, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(enum, ERR_CONSTRAINT_VIOLATION)
def test_remove_ldapdisplayname(self):
"""Testing removing the ldapdisplayname"""
self.fail("Should have failed to remove the ldapdisplayname")
except LdbError as e10:
(enum, estr) = e10.args
- self.assertEquals(enum, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(enum, ERR_OBJECT_CLASS_VIOLATION)
def test_rename_ldapdisplayname(self):
"""Testing renaming ldapdisplayname"""
self.fail("Should have failed to modify schema to have different attributeID")
except LdbError as e11:
(enum, estr) = e11.args
- self.assertEquals(enum, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(enum, ERR_CONSTRAINT_VIOLATION)
def test_change_attributeID_same(self):
"""Testing change the attributeID to the same value"""
self.fail("Should have failed to modify schema to have the same attributeID")
except LdbError as e12:
(enum, estr) = e12.args
- self.assertEquals(enum, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(enum, ERR_CONSTRAINT_VIOLATION)
def test_generated_linkID(self):
"""
# linkID generation isn't available before 2003
res = self.ldb.search(base="", expression="", scope=SCOPE_BASE,
attrs=["domainControllerFunctionality"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
dc_level = int(res[0]["domainControllerFunctionality"][0])
if dc_level < DS_DOMAIN_FUNCTION_2003:
return
res = self.ldb.search("CN=%s,%s" % (attr_name_1, self.schema_dn),
scope=SCOPE_BASE,
attrs=["linkID"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
linkID_1 = int(res[0]["linkID"][0])
res = self.ldb.search("CN=%s,%s" % (attr_name_2, self.schema_dn),
scope=SCOPE_BASE,
attrs=["linkID"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
linkID_2 = int(res[0]["linkID"][0])
# 0 should never be generated as a linkID
self.fail("Should have failed to add duplicate linkID value")
except LdbError as e15:
(enum, estr) = e15.args
- self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(enum, ERR_UNWILLING_TO_PERFORM)
# If we add another attribute with the attributeID or lDAPDisplayName
# of a forward link in its linkID field, it should add as a backlink
res = self.ldb.search("CN=%s,%s" % (attr_name_3, self.schema_dn),
scope=SCOPE_BASE,
attrs=["linkID"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
linkID = int(res[0]["linkID"][0])
- self.assertEquals(linkID, linkID_1 + 1)
+ self.assertEqual(linkID, linkID_1 + 1)
attr_name_4 = "test-generated-linkID-backlink-2" + time.strftime("%s", time.gmtime()) + "-" + rand
attr_ldap_display_name_4 = attr_name_4.replace("-", "")
res = self.ldb.search("CN=%s,%s" % (attr_name_4, self.schema_dn),
scope=SCOPE_BASE,
attrs=["linkID"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
linkID = int(res[0]["linkID"][0])
- self.assertEquals(linkID, linkID_2 + 1)
+ self.assertEqual(linkID, linkID_2 + 1)
# If we then try to add another backlink in the same way
# for the same forwards link, we should fail.
self.fail("Should have failed to add duplicate backlink")
except LdbError as e18:
(enum, estr) = e18.args
- self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(enum, ERR_UNWILLING_TO_PERFORM)
# If we try to supply the attributeID or ldapDisplayName
# of an existing backlink in the linkID field of a new link,
self.fail("Should have failed to add backlink of backlink")
except LdbError as e19:
(enum, estr) = e19.args
- self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(enum, ERR_UNWILLING_TO_PERFORM)
attr_name = "test-generated-linkID-backlink-invalid-2" + time.strftime("%s", time.gmtime()) + "-" + rand
attr_ldap_display_name = attr_name.replace("-", "")
self.fail("Should have failed to add backlink of backlink")
except LdbError as e20:
(enum, estr) = e20.args
- self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(enum, ERR_UNWILLING_TO_PERFORM)
def test_generated_mAPIID(self):
"""
res = self.ldb.search("CN=%s,%s" % (attr_name_1, self.schema_dn),
scope=SCOPE_BASE,
attrs=["mAPIID"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
mAPIID_1 = int(res[0]["mAPIID"][0])
ldif = """
self.fail("Should have failed to add duplicate mAPIID value")
except LdbError as e22:
(enum, estr) = e22.args
- self.assertEquals(enum, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(enum, ERR_UNWILLING_TO_PERFORM)
def test_change_governsID(self):
"""Testing change the governsID"""
self.fail("Should have failed to modify schema to have different governsID")
except LdbError as e23:
(enum, estr) = e23.args
- self.assertEquals(enum, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(enum, ERR_CONSTRAINT_VIOLATION)
def test_change_governsID_same(self):
"""Testing change the governsID"""
self.fail("Should have failed to modify schema to have the same governsID")
except LdbError as e24:
(enum, estr) = e24.args
- self.assertEquals(enum, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(enum, ERR_CONSTRAINT_VIOLATION)
class SchemaTests_msDS_IntId(samba.tests.TestCase):
res = self.ldb.search(base="", expression="", scope=SCOPE_BASE,
attrs=["schemaNamingContext", "defaultNamingContext",
"forestFunctionality"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.schema_dn = res[0]["schemaNamingContext"][0]
self.base_dn = res[0]["defaultNamingContext"][0]
self.forest_level = int(res[0]["forestFunctionality"][0])
self.fail("Adding attribute with preset msDS-IntId should fail")
except LdbError as e25:
(num, _) = e25.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# add the new attribute and update schema
self.ldb.add_ldif(ldif)
res = []
res = self.ldb.search(attr_dn, scope=SCOPE_BASE,
attrs=["lDAPDisplayName", "msDS-IntId", "systemFlags"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["lDAPDisplayName"][0]), attr_ldap_name)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["lDAPDisplayName"][0]), attr_ldap_name)
if self.forest_level >= DS_DOMAIN_FUNCTION_2003:
if self._is_schema_base_object(res[0]):
self.assertTrue("msDS-IntId" not in res[0])
self.fail("Modifying msDS-IntId should return error")
except LdbError as e26:
(num, _) = e26.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
# 2. Create attribute with systemFlags = FLAG_SCHEMA_BASE_OBJECT
# msDS-IntId should be created if forest functional
self.fail("Adding attribute with preset msDS-IntId should fail")
except LdbError as e27:
(num, _) = e27.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# add the new attribute and update schema
self.ldb.add_ldif(ldif)
res = []
res = self.ldb.search(attr_dn, scope=SCOPE_BASE,
attrs=["lDAPDisplayName", "msDS-IntId"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["lDAPDisplayName"][0]), attr_ldap_name)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["lDAPDisplayName"][0]), attr_ldap_name)
if self.forest_level >= DS_DOMAIN_FUNCTION_2003:
if self._is_schema_base_object(res[0]):
self.assertTrue("msDS-IntId" not in res[0])
self.fail("Modifying msDS-IntId should return error")
except LdbError as e28:
(num, _) = e28.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
def _make_class_ldif(self, class_dn, class_name, sub_oid):
ldif = """
self._ldap_schemaUpdateNow()
res = self.ldb.search(class_dn, scope=SCOPE_BASE, attrs=["msDS-IntId"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["msDS-IntId"][0]), "-1993108831")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["msDS-IntId"][0]), "-1993108831")
# add a new Class and update schema
(class_name, class_ldap_name, class_dn) = self._make_obj_names("msDS-IntId-Class-2-")
# Search for created Class
res = self.ldb.search(class_dn, scope=SCOPE_BASE, attrs=["msDS-IntId"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertFalse("msDS-IntId" in res[0])
msg = Message()
self.fail("Modifying msDS-IntId should return error")
except LdbError as e29:
(num, _) = e29.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
# 2. Create Class with systemFlags = FLAG_SCHEMA_BASE_OBJECT
# msDS-IntId should be created if forest functional
self.ldb.add_ldif(ldif_add)
res = self.ldb.search(class_dn, scope=SCOPE_BASE, attrs=["msDS-IntId"])
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["msDS-IntId"][0]), "-1993108831")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["msDS-IntId"][0]), "-1993108831")
# add the new Class and update schema
(class_name, class_ldap_name, class_dn) = self._make_obj_names("msDS-IntId-Class-4-")
# Search for created Class
res = self.ldb.search(class_dn, scope=SCOPE_BASE, attrs=["msDS-IntId"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertFalse("msDS-IntId" in res[0])
msg = Message()
self.fail("Modifying msDS-IntId should return error")
except LdbError as e30:
(num, _) = e30.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
res = self.ldb.search(class_dn, scope=SCOPE_BASE, attrs=["msDS-IntId"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertFalse("msDS-IntId" in res[0])
def test_verify_msDS_IntId(self):
self.ldb = SamDB(host, credentials=creds,
session_info=system_session(lp), lp=lp, options=ldb_options)
res = self.ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["defaultNamingContext"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.base_dn = res[0]["defaultNamingContext"][0]
def test_objectClass_ntdsdsa(self):
res_check = self.ldb.search(ntds_search_dn, attrs=["objectCategory"])
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
print("Server entry %s doesn't have a NTDS settings object" % res[0]['dn'])
else:
self.assertTrue("objectCategory" in res_check[0])
# search for created attribute
res = []
res = self.ldb.search("cn=%s,%s" % (attr_name, self.schema_dn), scope=SCOPE_BASE, attrs=["*"])
- self.assertEquals(len(res), 1)
- self.assertEquals(res[0]["lDAPDisplayName"][0], attr_ldap_display_name)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(res[0]["lDAPDisplayName"][0], attr_ldap_display_name)
self.assertTrue("schemaIDGUID" in res[0])
class_name = "test-Class-DN-String" + time.strftime("%s", time.gmtime())
# search for created objectclass
res = []
res = self.ldb.search("cn=%s,%s" % (class_name, self.schema_dn), scope=SCOPE_BASE, attrs=["*"])
- self.assertEquals(len(res), 1)
- self.assertEquals(res[0]["lDAPDisplayName"][0], class_ldap_display_name)
- self.assertEquals(res[0]["defaultObjectCategory"][0], res[0]["distinguishedName"][0])
+ self.assertEqual(len(res), 1)
+ self.assertEqual(res[0]["lDAPDisplayName"][0], class_ldap_display_name)
+ self.assertEqual(res[0]["defaultObjectCategory"][0], res[0]["distinguishedName"][0])
self.assertTrue("schemaIDGUID" in res[0])
# store the class and the attribute
# search for created attribute
res = []
res = self.ldb.search("cn=%s,%s" % (attr_name, self.schema_dn), scope=SCOPE_BASE, attrs=["*"])
- self.assertEquals(len(res), 1)
- self.assertEquals(res[0]["lDAPDisplayName"][0], attr_ldap_display_name)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(res[0]["lDAPDisplayName"][0], attr_ldap_display_name)
self.assertTrue("schemaIDGUID" in res[0])
class_name = "test-Class-DN-Binary" + time.strftime("%s", time.gmtime())
# search for created objectclass
res = []
res = self.ldb.search("cn=%s,%s" % (class_name, self.schema_dn), scope=SCOPE_BASE, attrs=["*"])
- self.assertEquals(len(res), 1)
- self.assertEquals(res[0]["lDAPDisplayName"][0], class_ldap_display_name)
- self.assertEquals(res[0]["defaultObjectCategory"][0], res[0]["distinguishedName"][0])
+ self.assertEqual(len(res), 1)
+ self.assertEqual(res[0]["lDAPDisplayName"][0], class_ldap_display_name)
+ self.assertEqual(res[0]["defaultObjectCategory"][0], res[0]["distinguishedName"][0])
self.assertTrue("schemaIDGUID" in res[0])
# store the class and the attribute
res = self.ldb.search(base=self.base_dn,
scope=SCOPE_SUBTREE,
expression="(%s=%s)" % (self.dn_string_attribute, self.base_dn))
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# search by specifying the string part only
res = self.ldb.search(base=self.base_dn,
scope=SCOPE_SUBTREE,
expression="(%s=S:5:ABCDE)" % self.dn_string_attribute)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# search by DN+Stirng
res = self.ldb.search(base=self.base_dn,
scope=SCOPE_SUBTREE,
expression="(%s=S:5:ABCDE:%s)" % (self.dn_string_attribute, self.base_dn))
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
# add object with wrong format
object_name2 = "obj-DN-String2" + time.strftime("%s", time.gmtime())
self.ldb.add_ldif(ldif)
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
# add object with the same dn but with different string value in case
ldif = self._get_object_ldif(object_name1, self.dn_string_class_name, self.dn_string_class_ldap_display_name,
self.ldb.add_ldif(ldif)
except LdbError as e1:
(num, _) = e1.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with the same dn but with different string value
ldif = self._get_object_ldif(object_name1, self.dn_string_class_name, self.dn_string_class_ldap_display_name,
self.ldb.add_ldif(ldif)
except LdbError as e2:
(num, _) = e2.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with the same dn but with different dn and string value
ldif = self._get_object_ldif(object_name1, self.dn_string_class_name, self.dn_string_class_ldap_display_name,
self.ldb.add_ldif(ldif)
except LdbError as e3:
(num, _) = e3.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with the same dn but with different dn value
ldif = self._get_object_ldif(object_name1, self.dn_string_class_name, self.dn_string_class_ldap_display_name,
self.ldb.add_ldif(ldif)
except LdbError as e4:
(num, _) = e4.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with GUID instead of DN
object_name3 = "obj-DN-String3" + time.strftime("%s", time.gmtime())
self.ldb.add_ldif(ldif)
except LdbError as e5:
(num, _) = e5.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
# add object with SID instead of DN
object_name4 = "obj-DN-String4" + time.strftime("%s", time.gmtime())
self.ldb.add_ldif(ldif)
except LdbError as e6:
(num, _) = e6.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
# add object with random string instead of DN
object_name5 = "obj-DN-String5" + time.strftime("%s", time.gmtime())
self.ldb.add_ldif(ldif)
except LdbError as e7:
(num, _) = e7.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
def test_dn_binary(self):
# add obeject with correct value
res = self.ldb.search(base=self.base_dn,
scope=SCOPE_SUBTREE,
expression="(%s=%s)" % (self.dn_binary_attribute, self.base_dn))
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# search by specifying the binary part
res = self.ldb.search(base=self.base_dn,
scope=SCOPE_SUBTREE,
expression="(%s=B:4:1234)" % self.dn_binary_attribute)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
# search by DN+Binary
res = self.ldb.search(base=self.base_dn,
scope=SCOPE_SUBTREE,
expression="(%s=B:4:1234:%s)" % (self.dn_binary_attribute, self.base_dn))
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
# add object with wrong format - 5 bytes instead of 4, 8, 16, 32...
object_name2 = "obj-DN-Binary2" + time.strftime("%s", time.gmtime())
self.ldb.add_ldif(ldif)
except LdbError as e8:
(num, _) = e8.args
- self.assertEquals(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
+ self.assertEqual(num, ERR_INVALID_ATTRIBUTE_SYNTAX)
# add object with the same dn but with different binary value
ldif = self._get_object_ldif(object_name1, self.dn_binary_class_name, self.dn_binary_class_ldap_display_name,
self.ldb.add_ldif(ldif)
except LdbError as e9:
(num, _) = e9.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with the same dn but with different binary and dn value
ldif = self._get_object_ldif(object_name1, self.dn_binary_class_name, self.dn_binary_class_ldap_display_name,
self.ldb.add_ldif(ldif)
except LdbError as e10:
(num, _) = e10.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with the same dn but with different dn value
ldif = self._get_object_ldif(object_name1, self.dn_binary_class_name, self.dn_binary_class_ldap_display_name,
self.ldb.add_ldif(ldif)
except LdbError as e11:
(num, _) = e11.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# add object with GUID instead of DN
object_name3 = "obj-DN-Binary3" + time.strftime("%s", time.gmtime())
self.ldb.add_ldif(ldif)
except LdbError as e12:
(num, _) = e12.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
# add object with SID instead of DN
object_name4 = "obj-DN-Binary4" + time.strftime("%s", time.gmtime())
self.ldb.add_ldif(ldif)
except LdbError as e13:
(num, _) = e13.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
# add object with random string instead of DN
object_name5 = "obj-DN-Binary5" + time.strftime("%s", time.gmtime())
self.ldb.add_ldif(ldif)
except LdbError as e14:
(num, _) = e14.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
TestProgram(module=__name__, opts=subunitopts)
self.base_dn = self.ldb.domain_dn()
res = self.ldb.search("", scope=ldb.SCOPE_BASE, attrs=["tokenGroups"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.user_sid_dn = "<SID=%s>" % str(ndr_unpack(samba.dcerpc.security.dom_sid, res[0]["tokenGroups"][0]))
self.fail()
except LdbError as e10:
(num, _) = e10.args
- self.assertEquals(num, ERR_TIME_LIMIT_EXCEEDED)
+ self.assertEqual(num, ERR_TIME_LIMIT_EXCEEDED)
self.assertIsNotNone(msg3)
self.ldb.modify_ldif("""
self.fail()
except LdbError as e1:
(num, _) = e1.args
- self.assertEquals(num, ERR_TIME_LIMIT_EXCEEDED)
+ self.assertEqual(num, ERR_TIME_LIMIT_EXCEEDED)
try:
hnd = self.ldb.search_iterator(base=self.base_dn,
self.fail()
except LdbError as e2:
(num, _) = e2.args
- self.assertEquals(num, ERR_TIME_LIMIT_EXCEEDED)
+ self.assertEqual(num, ERR_TIME_LIMIT_EXCEEDED)
try:
hnd = self.ldb.search_iterator(base=self.base_dn,
self.fail()
except LdbError as e3:
(num, _) = e3.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
hnd = self.ldb.search_iterator(base=self.base_dn,
self.fail()
except LdbError as e4:
(num, _) = e4.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
hnd = self.ldb.search_iterator(base=self.base_dn,
self.fail()
except LdbError as e5:
(num, _) = e5.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
hnd = self.ldb.search_iterator(base=self.base_dn,
self.fail()
except LdbError as e6:
(num, _) = e6.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
hnd = self.ldb.search_iterator(base=self.base_dn,
self.fail()
except LdbError as e7:
(num, _) = e7.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
hnd = self.ldb.search_iterator(base=self.base_dn,
self.fail()
except LdbError as e8:
(num, _) = e8.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
res = self.ldb.search(base=self.ldb.get_schema_basedn(),
expression="(objectClass=attributeSchema)",
(num, _) = e9.args
if num != ERR_UNWILLING_TO_PERFORM:
print("va[%s]" % va)
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
va = "noneAttributeName"
(num, _) = e11.args
if num != ERR_UNWILLING_TO_PERFORM:
print("va[%s]" % va)
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
if "://" not in url:
self.fail()
except LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e1:
(num, msg) = e1.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e2:
(num, msg) = e2.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e3:
(num, msg) = e3.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e4:
(num, msg) = e4.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e5:
(num, msg) = e5.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e6:
(num, msg) = e6.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e7:
(num, msg) = e7.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e8:
(num, msg) = e8.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e9:
(num, msg) = e9.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
res = self._check_account(userdn,
self.fail("Invalid SAMR change_password accepted")
except NTSTATUSError as e:
enum = ctypes.c_uint32(e.args[0]).value
- self.assertEquals(enum, ntstatus.NT_STATUS_WRONG_PASSWORD)
+ self.assertEqual(enum, ntstatus.NT_STATUS_WRONG_PASSWORD)
# check the status of the account is updated after each bad attempt
account_flags = 0
self.fail("Invalid SAMR change_password accepted")
except NTSTATUSError as e:
enum = ctypes.c_uint32(e.args[0]).value
- self.assertEquals(enum, ntstatus.NT_STATUS_ACCOUNT_LOCKED_OUT)
+ self.assertEqual(enum, ntstatus.NT_STATUS_ACCOUNT_LOCKED_OUT)
res = self._check_account(userdn,
badPwdCount=lockout_threshold,
self.fail()
except LdbError as e10:
(num, msg) = e10.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e11:
(num, msg) = e11.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e12:
(num, msg) = e12.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
# this is strange, why do we have lockoutTime=badPasswordTime here?
self.fail()
except LdbError as e13:
(num, msg) = e13.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e14:
(num, msg) = e14.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e15:
(num, msg) = e15.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000775' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e16:
(num, msg) = e16.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e17:
(num, msg) = e17.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e18:
(num, msg) = e18.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg, msg)
res = self._check_account(userdn,
self.fail()
except LdbError as e19:
(num, msg) = e19.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
# Windows (2008 at least) seems to have some small bug here: it
# returns "0000056A" on longer (always wrong) previous passwords.
self.assertTrue('00000056' in msg, msg)
self.assertTrue("objectSid" in res[0])
(domain_sid, rid) = ndr_unpack(security.dom_sid, res[0]["objectSid"][0]).split()
- self.assertEquals(self.domain_sid, domain_sid)
+ self.assertEqual(self.domain_sid, domain_sid)
return self.samr.OpenUser(self.samr_domain, security.SEC_FLAG_MAXIMUM_ALLOWED, rid)
if msDSUserAccountControlComputed & dsdb.UF_PASSWORD_EXPIRED:
expected_acb_info |= samr.ACB_PW_EXPIRED
- self.assertEquals(uinfo3.acct_flags, expected_acb_info)
- self.assertEquals(uinfo3.last_logon, lastLogon)
- self.assertEquals(uinfo3.logon_count, logonCount)
+ self.assertEqual(uinfo3.acct_flags, expected_acb_info)
+ self.assertEqual(uinfo3.last_logon, lastLogon)
+ self.assertEqual(uinfo3.logon_count, logonCount)
expected_bad_password_count = 0
if badPwdCount is not None:
if effective_bad_password_count is None:
effective_bad_password_count = expected_bad_password_count
- self.assertEquals(uinfo3.bad_password_count, expected_bad_password_count)
+ self.assertEqual(uinfo3.bad_password_count, expected_bad_password_count)
if not badPwdCountOnly:
- self.assertEquals(uinfo5.acct_flags, expected_acb_info)
- self.assertEquals(uinfo5.bad_password_count, effective_bad_password_count)
- self.assertEquals(uinfo5.last_logon, lastLogon)
- self.assertEquals(uinfo5.logon_count, logonCount)
+ self.assertEqual(uinfo5.acct_flags, expected_acb_info)
+ self.assertEqual(uinfo5.bad_password_count, effective_bad_password_count)
+ self.assertEqual(uinfo5.last_logon, lastLogon)
+ self.assertEqual(uinfo5.logon_count, logonCount)
- self.assertEquals(uinfo16.acct_flags, expected_acb_info)
+ self.assertEqual(uinfo16.acct_flags, expected_acb_info)
- self.assertEquals(uinfo21.acct_flags, expected_acb_info)
- self.assertEquals(uinfo21.bad_password_count, effective_bad_password_count)
- self.assertEquals(uinfo21.last_logon, lastLogon)
- self.assertEquals(uinfo21.logon_count, logonCount)
+ self.assertEqual(uinfo21.acct_flags, expected_acb_info)
+ self.assertEqual(uinfo21.bad_password_count, effective_bad_password_count)
+ self.assertEqual(uinfo21.last_logon, lastLogon)
+ self.assertEqual(uinfo21.logon_count, logonCount)
# check LDAP again and make sure the samr.QueryUserInfo
# doesn't have any impact.
res2 = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
- self.assertEquals(res[0], res2[0])
+ self.assertEqual(res[0], res2[0])
# in order to prevent some time resolution problems we sleep for
# 10 micro second
self.fail()
except LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
# Succeed to reset everything to 0
ldb = SamDB(url=self.host_url, credentials=creds, lp=self.lp)
except LdbError as e1:
(num, msg) = e1.args
if errno is not None:
- self.assertEquals(num, errno, ("Login failed in the wrong way"
+ self.assertEqual(num, errno, ("Login failed in the wrong way"
"(got err %d, expected %d)" %
(num, errno)))
except LdbError as e2:
(num, msg) = e2.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=2,
except LdbError as e3:
(num, msg) = e3.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=3,
self.fail()
except LdbError as e4:
(num, msg) = e4.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=3,
self.fail()
except LdbError as e5:
(num, msg) = e5.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=3,
self.fail()
except LdbError as e6:
(num, msg) = e6.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=3,
self.fail()
except LdbError as e7:
(num, msg) = e7.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=1,
self.fail()
except LdbError as e8:
(num, msg) = e8.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=2,
self.fail()
except LdbError as e9:
(num, msg) = e9.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=1,
self.fail("Password '%s' should have been rejected" % password)
except ldb.LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ldb.ERR_CONSTRAINT_VIOLATION, msg)
+ self.assertEqual(num, ldb.ERR_CONSTRAINT_VIOLATION, msg)
self.assertTrue('0000052D' in msg, msg)
def assert_password_valid(self, user, password):
self.fail()
except ldb.LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ldb.ERR_NAMING_VIOLATION, msg)
+ self.assertEqual(num, ldb.ERR_NAMING_VIOLATION, msg)
# Windows returns 2099 (Illegal superior), Samba returns 2037
# (Naming violation - "not a valid child class")
self.assertTrue('00002099' in msg or '00002037' in msg, msg)
self.fail()
except ldb.LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ldb.ERR_NAMING_VIOLATION, msg)
+ self.assertEqual(num, ldb.ERR_NAMING_VIOLATION, msg)
self.assertTrue('00002099' in msg or '00002037' in msg, msg)
base_dn = self.ldb.get_default_basedn()
self.fail()
except ldb.LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, msg)
+ self.assertEqual(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, msg)
# create a PSO as the admin user
priv_pso = PasswordSettings("priv-PSO", self.ldb, password_len=20)
self.fail()
except ldb.LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, msg)
+ self.assertEqual(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, msg)
self.assertTrue('00002098' in msg, msg)
self.set_attribute(priv_pso.dn, "msDS-PSOAppliesTo", user.dn,
self.fail()
except ldb.LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, msg)
+ self.assertEqual(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, msg)
self.assertTrue('00002098' in msg, msg)
priv_pso.set_precedence(100, samdb=self.ldb)
self.fail()
except ldb.LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, msg)
+ self.assertEqual(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, msg)
self.assertTrue('00002098' in msg, msg)
# ...but can be performed by the admin user
self.fail()
except ldb.LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ldb.ERR_CONSTRAINT_VIOLATION, msg)
+ self.assertEqual(num, ldb.ERR_CONSTRAINT_VIOLATION, msg)
self.assertTrue('0000052D' in msg, msg)
# check setting a password that meets the PSO settings works
self.fail()
except LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
# Windows (2008 at least) seems to have some small bug here: it
# returns "0000056A" on longer (always wrong) previous passwords.
self.assertTrue('00000056' in msg)
self.fail()
except LdbError as e1:
(num, _) = e1.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
# Enables the user account
self.ldb.enable_account("(sAMAccountName=testuser)")
self.fail()
except LdbError as e2:
(num, _) = e2.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
def test_unicodePwd_hash_change(self):
"""Performs a password hash change operation on 'unicodePwd' which should be prevented"""
self.fail()
except LdbError as e3:
(num, _) = e3.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
def test_unicodePwd_clear_set(self):
"""Performs a password cleartext set operation on 'unicodePwd'"""
self.fail()
except LdbError as e4:
(num, msg) = e4.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg)
# A change to the same password again will not work (password history)
self.fail()
except LdbError as e5:
(num, msg) = e5.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('0000052D' in msg)
def test_dBCSPwd_hash_set(self):
self.fail()
except LdbError as e6:
(num, _) = e6.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
def test_dBCSPwd_hash_change(self):
"""Performs a password hash change operation on 'dBCSPwd' which should be prevented"""
self.fail()
except LdbError as e7:
(num, _) = e7.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
def test_userPassword_clear_set(self):
"""Performs a password cleartext set operation on 'userPassword'"""
self.fail()
except LdbError as e8:
(num, msg) = e8.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg)
# A change to the same password again will not work (password history)
self.fail()
except LdbError as e9:
(num, msg) = e9.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('0000052D' in msg)
def test_clearTextPassword_clear_set(self):
(num, msg) = e12.args
# "NO_SUCH_ATTRIBUTE" is returned by Windows -> ignore it
if num != ERR_NO_SUCH_ATTRIBUTE:
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('00000056' in msg)
# A change to the same password again will not work (password history)
(num, msg) = e13.args
# "NO_SUCH_ATTRIBUTE" is returned by Windows -> ignore it
if num != ERR_NO_SUCH_ATTRIBUTE:
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
self.assertTrue('0000052D' in msg)
def test_failures(self):
self.fail()
except LdbError as e14:
(num, _) = e14.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb2.modify_ldif("""
self.fail()
except LdbError as e15:
(num, _) = e15.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb.modify_ldif("""
self.fail()
except LdbError as e16:
(num, _) = e16.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb2.modify_ldif("""
self.fail()
except LdbError as e17:
(num, _) = e17.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb.modify_ldif("""
self.fail()
except LdbError as e18:
(num, _) = e18.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb2.modify_ldif("""
self.fail()
except LdbError as e19:
(num, _) = e19.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
try:
self.ldb.modify_ldif("""
self.fail()
except LdbError as e20:
(num, _) = e20.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb2.modify_ldif("""
self.fail()
except LdbError as e21:
(num, _) = e21.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb.modify_ldif("""
self.fail()
except LdbError as e22:
(num, _) = e22.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb2.modify_ldif("""
self.fail()
except LdbError as e23:
(num, _) = e23.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb.modify_ldif("""
self.fail()
except LdbError as e24:
(num, _) = e24.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb2.modify_ldif("""
self.fail()
except LdbError as e25:
(num, _) = e25.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
try:
self.ldb.modify_ldif("""
self.fail()
except LdbError as e26:
(num, _) = e26.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb2.modify_ldif("""
self.fail()
except LdbError as e27:
(num, _) = e27.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
try:
self.ldb.modify_ldif("""
self.fail()
except LdbError as e28:
(num, _) = e28.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb2.modify_ldif("""
self.fail()
except LdbError as e29:
(num, _) = e29.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
# Reverse order does work
self.ldb2.modify_ldif("""
# this passes against s4
except LdbError as e30:
(num, _) = e30.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
try:
self.ldb2.modify_ldif("""
# this passes against s4
except LdbError as e31:
(num, _) = e31.args
- self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(num, ERR_NO_SUCH_ATTRIBUTE)
# Several password changes at once are allowed
self.ldb.modify_ldif("""
self.fail()
except LdbError as e32:
(num, _) = e32.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb.add({
self.fail()
except LdbError as e33:
(num, _) = e33.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb.add({
self.fail()
except LdbError as e34:
(num, _) = e34.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
try:
self.ldb.add({
self.fail()
except LdbError as e36:
(num, _) = e36.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
m.dn = Dn(self.ldb, "cn=testuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e37:
(num, _) = e37.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
m.dn = Dn(self.ldb, "cn=testuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e38:
(num, _) = e38.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
m.dn = Dn(self.ldb, "cn=testuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e40:
(num, _) = e40.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(self.ldb, "cn=testuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e41:
(num, _) = e41.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(self.ldb, "cn=testuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e42:
(num, _) = e42.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(self.ldb, "cn=testuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e44:
(num, _) = e44.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(self.ldb, "cn=testuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e45:
(num, _) = e45.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(self.ldb, "cn=testuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e46:
(num, _) = e46.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
m = Message()
m.dn = Dn(self.ldb, "cn=testuser,cn=users," + self.base_dn)
scope=SCOPE_BASE, attrs=["userPassword"])
self.assertTrue(len(res) == 1)
self.assertTrue("userPassword" in res[0])
- self.assertEquals(str(res[0]["userPassword"][0]), "myPassword")
+ self.assertEqual(str(res[0]["userPassword"][0]), "myPassword")
m = Message()
m.dn = Dn(self.ldb, "cn=testuser,cn=users," + self.base_dn)
scope=SCOPE_BASE, attrs=["userPassword"])
self.assertTrue(len(res) == 1)
self.assertTrue("userPassword" in res[0])
- self.assertEquals(str(res[0]["userPassword"][0]), "myPassword2")
+ self.assertEqual(str(res[0]["userPassword"][0]), "myPassword2")
m = Message()
m.dn = Dn(self.ldb, "cn=testuser,cn=users," + self.base_dn)
scope=SCOPE_BASE, attrs=["userPassword"])
self.assertTrue(len(res) == 1)
self.assertTrue("userPassword" in res[0])
- self.assertEquals(str(res[0]["userPassword"][0]), "myPassword3")
+ self.assertEqual(str(res[0]["userPassword"][0]), "myPassword3")
# Set the test "dSHeuristics" to deactivate "userPassword" pwd changes
self.ldb.set_dsheuristics("000000002")
scope=SCOPE_BASE, attrs=["userPassword"])
self.assertTrue(len(res) == 1)
self.assertTrue("userPassword" in res[0])
- self.assertEquals(str(res[0]["userPassword"][0]), "myPassword4")
+ self.assertEqual(str(res[0]["userPassword"][0]), "myPassword4")
# Reset the test "dSHeuristics" (reactivate "userPassword" pwd changes)
self.ldb.set_dsheuristics("000000001")
# userPassword can be read
self.assertTrue(len(res) == 1)
self.assertTrue("userPassword" in res[0])
- self.assertEquals(str(res[0]["userPassword"][0]), "thatsAcomplPASS2")
+ self.assertEqual(str(res[0]["userPassword"][0]), "thatsAcomplPASS2")
# Reset the test "dSHeuristics" (reactivate "userPassword" pwd changes)
self.ldb.set_dsheuristics("000000001")
""")
except LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
else:
self.fail()
""")
except LdbError as e:
(num, msg) = e.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
else:
self.fail()
except LdbError as e1:
(num, msg) = e1.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=2,
except LdbError as e2:
(num, msg) = e2.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=3,
self.fail()
except LdbError as e3:
(num, msg) = e3.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=3,
self.fail()
except LdbError as e4:
(num, msg) = e4.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=3,
self.fail()
except LdbError as e5:
(num, msg) = e5.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=3,
self.fail()
except LdbError as e6:
(num, msg) = e6.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=1,
self.fail()
except LdbError as e7:
(num, msg) = e7.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=2,
self.fail()
except LdbError as e8:
(num, msg) = e8.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
res = self._check_account(userdn,
badPwdCount=1,
self.fail()
except LdbError as e11:
(num, msg) = e11.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
# Succeed to reset everything to 0
success_creds = self.insta_creds(self.template_creds,
self.fail()
except LdbError as e12:
(num, msg) = e12.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
# Succeed to reset everything to 0
ldb = SamDB(url=self.host_url, credentials=self.lockout1ntlm_creds, lp=self.lp)
self.fail()
except LdbError as e13:
(num, msg) = e13.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
# Succeed to reset everything to 0
success_creds = self.insta_creds(self.template_creds,
self.fail()
except LdbError as e14:
(num, msg) = e14.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
# Succeed to reset everything to 0
ldb = SamDB(url=self.host_url, credentials=self.lockout1ntlm_creds, lp=self.lp)
self.fail()
except LdbError as e9:
(num, _) = e9.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
# Try to create a user with an invalid account name
self.fail()
except LdbError as e10:
(num, _) = e10.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
# Try to create a user with an invalid primary group
self.fail()
except LdbError as e11:
(num, _) = e11.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
# Try to Create a user with a valid primary group
self.fail()
except LdbError as e12:
(num, _) = e12.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
# Test to see how we should behave when the user account doesn't
self.fail()
except LdbError as e13:
(num, _) = e13.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
# Test to see how we should behave when the account isn't a user
m = Message()
self.fail()
except LdbError as e14:
(num, _) = e14.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
# Test default primary groups on add operations
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["primaryGroupID"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_USERS)
+ self.assertEqual(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_USERS)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["primaryGroupID"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_USERS)
+ self.assertEqual(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_USERS)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["primaryGroupID"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["primaryGroupID"][0]),
+ self.assertEqual(int(res1[0]["primaryGroupID"][0]),
DOMAIN_RID_DOMAIN_MEMBERS)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["primaryGroupID"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_DCS)
+ self.assertEqual(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_DCS)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["primaryGroupID"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_USERS)
+ self.assertEqual(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_USERS)
# unfortunately the INTERDOMAIN_TRUST_ACCOUNT case cannot be tested
# since such accounts aren't directly creatable (ACCESS_DENIED)
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["primaryGroupID"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_USERS)
+ self.assertEqual(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_USERS)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["primaryGroupID"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_DOMAIN_MEMBERS)
+ self.assertEqual(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_DOMAIN_MEMBERS)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["primaryGroupID"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_DCS)
+ self.assertEqual(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_DCS)
# Read-only DC accounts are only creatable by
# UF_WORKSTATION_TRUST_ACCOUNT and work only on DCs >= 2008 (therefore
self.fail()
except LdbError as e15:
(num, _) = e15.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# But to reset the actual "sAMAccountName" should still be possible
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
self.fail()
except LdbError as e16:
(num, _) = e16.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Try to make group 1 primary - should be denied since it is not yet
# secondary
self.fail()
except LdbError as e17:
(num, _) = e17.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Make group 1 secondary
m = Message()
self.fail()
except LdbError as e18:
(num, _) = e18.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# Try to add group 1 also as secondary - should be denied
m = Message()
self.fail()
except LdbError as e19:
(num, _) = e19.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# Try to add invalid member to group 1 - should be denied
m = Message()
self.fail()
except LdbError as e20:
(num, _) = e20.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
# Make group 2 secondary
m = Message()
scope=SCOPE_BASE, attrs=["member"])
self.assertTrue(len(res1) == 1)
self.assertTrue(len(res1[0]["member"]) == 1)
- self.assertEquals(str(res1[0]["member"][0]).lower(),
+ self.assertEqual(str(res1[0]["member"][0]).lower(),
("cn=ldaptestuser,cn=users," + self.base_dn).lower())
res1 = ldb.search("cn=ldaptestgroup2, cn=users," + self.base_dn,
self.fail()
except LdbError as e21:
(num, _) = e21.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Delete invalid group member
m = Message()
self.fail()
except LdbError as e22:
(num, _) = e22.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Also this should be denied
try:
self.fail()
except LdbError as e23:
(num, _) = e23.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Recreate user accounts
self.fail()
except LdbError as e24:
(num, _) = e24.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# Already added, but as <SID=...>
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
self.fail()
except LdbError as e25:
(num, _) = e25.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
# Invalid member
m = Message()
self.fail()
except LdbError as e26:
(num, _) = e26.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
# Invalid member
m = Message()
self.fail()
except LdbError as e27:
(num, _) = e27.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
# Invalid member
m = Message()
self.fail()
except LdbError as e28:
(num, _) = e28.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup2,cn=users," + self.base_dn)
self.fail()
except LdbError as e29:
(num, _) = e29.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
# Delete protection tests
self.fail()
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e1:
(num, _) = e1.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e30:
(num, _) = e30.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e31:
(num, _) = e31.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e32:
(num, _) = e32.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e33:
(num, _) = e33.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e34:
(num, _) = e34.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
# Delete protection tests
self.fail()
except LdbError as e2:
(num, _) = e2.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e3:
(num, _) = e3.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e35:
(num, _) = e35.args
- self.assertEquals(num, ERR_UNDEFINED_ATTRIBUTE_TYPE)
+ self.assertEqual(num, ERR_UNDEFINED_ATTRIBUTE_TYPE)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
ldb.add({
obj_sid = get_string(ldb.schema_format_value("objectSID", res1[0]["objectSID"][0]))
rid = security.dom_sid(obj_sid).split()[1]
- self.assertEquals(primary_group_token, rid)
+ self.assertEqual(primary_group_token, rid)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e36:
(num, _) = e36.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e37:
(num, _) = e37.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
try:
self.fail()
except LdbError as e38:
(num, _) = e38.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
ldb.add({
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_GLOBAL_GROUP)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_UNIVERSAL_GROUP)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_LOCAL_GROUP)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_DISTRIBUTION_GLOBAL_GROUP)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_DISTRIBUTION_UNIVERSAL_GROUP)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_DISTRIBUTION_LOCAL_GROUP)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_GLOBAL_GROUP)
# Invalid attribute
self.fail()
except LdbError as e39:
(num, _) = e39.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Security groups
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_GLOBAL_GROUP)
# Change to "local" (shouldn't work)
self.fail()
except LdbError as e40:
(num, _) = e40.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Change to "universal"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_UNIVERSAL_GROUP)
# Change back to "global"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_GLOBAL_GROUP)
# Change back to "universal"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_UNIVERSAL_GROUP)
# Change to "local"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_LOCAL_GROUP)
# Change to "global" (shouldn't work)
self.fail()
except LdbError as e41:
(num, _) = e41.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Change to "builtin local" (shouldn't work)
self.fail()
except LdbError as e42:
(num, _) = e42.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_UNIVERSAL_GROUP)
# Change to "builtin local" (shouldn't work)
self.fail()
except LdbError as e43:
(num, _) = e43.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Change back to "global"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_GLOBAL_GROUP)
# Change to "builtin local" (shouldn't work)
self.fail()
except LdbError as e44:
(num, _) = e44.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Distribution groups
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_DISTRIBUTION_GLOBAL_GROUP)
# Change to local (shouldn't work)
self.fail()
except LdbError as e45:
(num, _) = e45.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Change to "universal"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_DISTRIBUTION_UNIVERSAL_GROUP)
# Change back to "global"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_DISTRIBUTION_GLOBAL_GROUP)
# Change back to "universal"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_DISTRIBUTION_UNIVERSAL_GROUP)
# Change to "local"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_DISTRIBUTION_LOCAL_GROUP)
# Change to "global" (shouldn't work)
self.fail()
except LdbError as e46:
(num, _) = e46.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Change back to "universal"
self.fail()
except LdbError as e47:
(num, _) = e47.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
# Make group 2 secondary
m = Message()
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_DISTRIBUTION_UNIVERSAL_GROUP)
# Change back to "global"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_DISTRIBUTION_GLOBAL_GROUP)
# Both group types: this performs only random checks - all possibilities
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_GLOBAL_GROUP)
# Change to "local" (shouldn't work)
self.fail()
except LdbError as e48:
(num, _) = e48.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Change to "universal"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_DISTRIBUTION_UNIVERSAL_GROUP)
# Change back to "global"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_GLOBAL_GROUP)
# Change back to "universal"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_UNIVERSAL_GROUP)
# Change to "local"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_DISTRIBUTION_LOCAL_GROUP)
# Change to "global" (shouldn't work)
self.fail()
except LdbError as e49:
(num, _) = e49.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# Change back to "universal"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_UNIVERSAL_GROUP)
# Change back to "global"
res1 = ldb.search("cn=ldaptestgroup,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_SECURITY_GLOBAL_GROUP)
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e50:
(num, msg) = e50.args
- self.assertEquals(num, ERR_OTHER)
+ self.assertEqual(num, ERR_OTHER)
self.assertTrue('00000057' in msg)
try:
self.fail()
except LdbError as e51:
(num, msg) = e51.args
- self.assertEquals(num, ERR_OTHER)
+ self.assertEqual(num, ERR_OTHER)
self.assertTrue('00000057' in msg)
ldb.add({
self.fail()
except LdbError as e52:
(num, msg) = e52.args
- self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(num, ERR_NO_SUCH_ATTRIBUTE)
self.assertTrue('00002085' in msg)
try:
self.fail()
except LdbError as e53:
(num, msg) = e53.args
- self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(num, ERR_NO_SUCH_ATTRIBUTE)
self.assertTrue('00002085' in msg)
m = Message()
self.fail()
except LdbError as e54:
(num, msg) = e54.args
- self.assertEquals(num, ERR_OTHER)
+ self.assertEqual(num, ERR_OTHER)
self.assertTrue('00000057' in msg)
m = Message()
self.fail()
except LdbError as e56:
(num, msg) = e56.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
self.assertTrue(error_msg_sasl_wrong_pw in msg)
if not requires_strong_auth:
self.fail()
except LdbError as e4:
(num, msg) = e4.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
assertLDAPErrorMsg(msg, error_msg_simple_wrong_pw)
m = Message()
self.fail()
except LdbError as e57:
(num, msg) = e57.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
assertLDAPErrorMsg(msg, error_msg_sasl_wrong_pw)
try:
self.fail()
except LdbError as e58:
(num, msg) = e58.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
assertLDAPErrorMsg(msg, error_msg_sasl_must_change)
if not requires_strong_auth:
self.fail()
except LdbError as e5:
(num, msg) = e5.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
assertLDAPErrorMsg(msg, error_msg_simple_wrong_pw)
try:
self.fail()
except LdbError as e6:
(num, msg) = e6.args
- self.assertEquals(num, ERR_INVALID_CREDENTIALS)
+ self.assertEqual(num, ERR_INVALID_CREDENTIALS)
assertLDAPErrorMsg(msg, error_msg_simple_must_change)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_ACCOUNTDISABLE == 0)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_PASSWD_NOTREQD == 0)
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_ACCOUNTDISABLE == 0)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl", "lockoutTime", "pwdLastSet"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & (UF_LOCKOUT | UF_PASSWORD_EXPIRED) == 0)
self.assertFalse("lockoutTime" in res1[0])
self.fail()
except LdbError as e59:
(num, _) = e59.args
- self.assertEquals(num, ERR_OTHER)
+ self.assertEqual(num, ERR_OTHER)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
try:
self.fail()
except LdbError as e60:
(num, _) = e60.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
try:
"userAccountControl": str(UF_WORKSTATION_TRUST_ACCOUNT)})
except LdbError as e61:
(num, _) = e61.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
try:
"userAccountControl": str(UF_WORKSTATION_TRUST_ACCOUNT | UF_PARTIAL_SECRETS_ACCOUNT)})
except LdbError as e62:
(num, _) = e62.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
try:
self.fail()
except LdbError as e63:
(num, _) = e63.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
# Modify operation
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_ACCOUNTDISABLE != 0)
ldb.modify(m)
except LdbError as e64:
(num, _) = e64.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
m = Message()
ldb.modify(m)
except LdbError as e65:
(num, _) = e65.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_ACCOUNTDISABLE == 0)
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_NORMAL_ACCOUNT != 0)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_ACCOUNTDISABLE != 0)
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl", "lockoutTime", "pwdLastSet"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_NORMAL_ACCOUNT != 0)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & (UF_LOCKOUT | UF_PASSWORD_EXPIRED) == 0)
self.fail()
except LdbError as e66:
(num, _) = e66.args
- self.assertEquals(num, ERR_OTHER)
+ self.assertEqual(num, ERR_OTHER)
try:
m = Message()
self.fail()
except LdbError as e67:
(num, _) = e67.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
self.fail()
except LdbError as e68:
(num, _) = e68.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_WORKSTATION_TRUST)
m = Message()
res1 = ldb.search("cn=ldaptestuser,cn=users," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
try:
self.fail()
except LdbError as e69:
(num, _) = e69.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
# With a computer object
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_ACCOUNTDISABLE == 0)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_PASSWD_NOTREQD == 0)
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_ACCOUNTDISABLE == 0)
delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl", "lockoutTime", "pwdLastSet"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & (UF_LOCKOUT | UF_PASSWORD_EXPIRED) == 0)
self.assertFalse("lockoutTime" in res1[0])
self.fail()
except LdbError as e70:
(num, _) = e70.args
- self.assertEquals(num, ERR_OTHER)
+ self.assertEqual(num, ERR_OTHER)
delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
ldb.add({
res1 = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_WORKSTATION_TRUST)
delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
"userAccountControl": str(UF_WORKSTATION_TRUST_ACCOUNT)})
except LdbError as e71:
(num, _) = e71.args
- self.assertEquals(num, ERR_OBJECT_CLASS_VIOLATION)
+ self.assertEqual(num, ERR_OBJECT_CLASS_VIOLATION)
delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
try:
self.fail()
except LdbError as e72:
(num, _) = e72.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
# Modify operation
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_ACCOUNTDISABLE != 0)
ldb.modify(m)
except LdbError as e73:
(num, _) = e73.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
m = Message()
ldb.modify(m)
except LdbError as e74:
(num, _) = e74.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_ACCOUNTDISABLE == 0)
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_NORMAL_ACCOUNT != 0)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_ACCOUNTDISABLE != 0)
scope=SCOPE_BASE,
attrs=["sAMAccountType", "userAccountControl", "lockoutTime", "pwdLastSet"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_NORMAL_ACCOUNT != 0)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & (UF_LOCKOUT | UF_PASSWORD_EXPIRED) == 0)
self.fail()
except LdbError as e75:
(num, _) = e75.args
- self.assertEquals(num, ERR_OTHER)
+ self.assertEqual(num, ERR_OTHER)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
res1 = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_WORKSTATION_TRUST)
m = Message()
res1 = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
m = Message()
res1 = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_WORKSTATION_TRUST)
m = Message()
res1 = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_NORMAL_ACCOUNT)
m = Message()
res1 = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_WORKSTATION_TRUST)
m = Message()
res1 = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountType"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["sAMAccountType"][0]),
+ self.assertEqual(int(res1[0]["sAMAccountType"][0]),
ATYPE_WORKSTATION_TRUST)
try:
self.fail()
except LdbError as e76:
(num, _) = e76.args
- self.assertEquals(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
+ self.assertEqual(num, ERR_INSUFFICIENT_ACCESS_RIGHTS)
# "primaryGroupID" does not change if account type remains the same
scope=SCOPE_BASE,
attrs=["userAccountControl"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["userAccountControl"][0]),
+ self.assertEqual(int(res1[0]["userAccountControl"][0]),
UF_NORMAL_ACCOUNT | UF_PASSWD_NOTREQD | UF_ACCOUNTDISABLE)
m = Message()
attrs=["userAccountControl", "primaryGroupID"])
self.assertTrue(len(res1) == 1)
self.assertTrue(int(res1[0]["userAccountControl"][0]) & UF_ACCOUNTDISABLE == 0)
- self.assertEquals(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_ADMINS)
+ self.assertEqual(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_ADMINS)
# For a workstation account
scope=SCOPE_BASE,
attrs=["primaryGroupID"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_DOMAIN_MEMBERS)
+ self.assertEqual(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_DOMAIN_MEMBERS)
m = Message()
m.dn = Dn(ldb, "<SID=" + ldb.get_domain_sid() + "-" + str(DOMAIN_RID_USERS) + ">")
scope=SCOPE_BASE,
attrs=["primaryGroupID"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_USERS)
+ self.assertEqual(int(res1[0]["primaryGroupID"][0]), DOMAIN_RID_USERS)
delete_force(self.ldb, "cn=ldaptestuser,cn=users," + self.base_dn)
delete_force(self.ldb, "cn=ldaptestuser2,cn=users," + self.base_dn)
scope=SCOPE_BASE,
attrs=["isCriticalSystemObject"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(str(res1[0]["isCriticalSystemObject"][0]), "FALSE")
+ self.assertEqual(str(res1[0]["isCriticalSystemObject"][0]), "FALSE")
delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
scope=SCOPE_BASE,
attrs=["isCriticalSystemObject"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(str(res1[0]["isCriticalSystemObject"][0]), "TRUE")
+ self.assertEqual(str(res1[0]["isCriticalSystemObject"][0]), "TRUE")
delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
scope=SCOPE_BASE,
attrs=["isCriticalSystemObject"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(str(res1[0]["isCriticalSystemObject"][0]), "TRUE")
+ self.assertEqual(str(res1[0]["isCriticalSystemObject"][0]), "TRUE")
# Modification tests
scope=SCOPE_BASE,
attrs=["isCriticalSystemObject"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(str(res1[0]["isCriticalSystemObject"][0]), "TRUE")
+ self.assertEqual(str(res1[0]["isCriticalSystemObject"][0]), "TRUE")
m = Message()
m.dn = Dn(ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
scope=SCOPE_BASE,
attrs=["isCriticalSystemObject"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(str(res1[0]["isCriticalSystemObject"][0]), "FALSE")
+ self.assertEqual(str(res1[0]["isCriticalSystemObject"][0]), "FALSE")
m = Message()
m.dn = Dn(ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
scope=SCOPE_BASE,
attrs=["isCriticalSystemObject"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(str(res1[0]["isCriticalSystemObject"][0]), "TRUE")
+ self.assertEqual(str(res1[0]["isCriticalSystemObject"][0]), "TRUE")
m = Message()
m.dn = Dn(ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
scope=SCOPE_BASE,
attrs=["isCriticalSystemObject"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(str(res1[0]["isCriticalSystemObject"][0]), "TRUE")
+ self.assertEqual(str(res1[0]["isCriticalSystemObject"][0]), "TRUE")
m = Message()
m.dn = Dn(ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
scope=SCOPE_BASE,
attrs=["isCriticalSystemObject"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(str(res1[0]["isCriticalSystemObject"][0]), "TRUE")
+ self.assertEqual(str(res1[0]["isCriticalSystemObject"][0]), "TRUE")
m = Message()
m.dn = Dn(ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
scope=SCOPE_BASE,
attrs=["isCriticalSystemObject"])
self.assertTrue(len(res1) == 1)
- self.assertEquals(str(res1[0]["isCriticalSystemObject"][0]), "FALSE")
+ self.assertEqual(str(res1[0]["isCriticalSystemObject"][0]), "FALSE")
delete_force(self.ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["dNSHostName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["dNSHostName"][0]), "testname2.testdom")
+ self.assertEqual(str(res[0]["dNSHostName"][0]), "testname2.testdom")
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname.testdom")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname.testdom")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname2.testdom2")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname2.testdom2")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname2.testdom2")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname3.testdom3")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname2.testdom2")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["sAMAccountName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["sAMAccountName"][0]), "testname$")
+ self.assertEqual(str(res[0]["sAMAccountName"][0]), "testname$")
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/test$name")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname2")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname3")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["servicePrincipalName"][0]),
+ self.assertEqual(str(res[0]["servicePrincipalName"][0]),
"HOST/testname2")
m = Message()
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["dNSHostName", "sAMAccountName", "servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["dNSHostName"][0]), "testname2.testdom")
- self.assertEquals(str(res[0]["sAMAccountName"][0]), "testname2$")
+ self.assertEqual(str(res[0]["dNSHostName"][0]), "testname2.testdom")
+ self.assertEqual(str(res[0]["sAMAccountName"][0]), "testname2$")
self.assertTrue(str(res[0]["servicePrincipalName"][0]) == "HOST/testname2" or
str(res[0]["servicePrincipalName"][1]) == "HOST/testname2")
self.assertTrue(str(res[0]["servicePrincipalName"][0]) == "HOST/testname2.testdom" or
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["dNSHostName", "sAMAccountName", "servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["dNSHostName"][0]), "testname2.testdom")
- self.assertEquals(str(res[0]["sAMAccountName"][0]), "testname2$")
+ self.assertEqual(str(res[0]["dNSHostName"][0]), "testname2.testdom")
+ self.assertEqual(str(res[0]["sAMAccountName"][0]), "testname2$")
self.assertTrue(len(res[0]["servicePrincipalName"]) == 2)
self.assertTrue("HOST/testname2" in [str(x) for x in res[0]["servicePrincipalName"]])
self.assertTrue("HOST/testname2.testdom" in [str(x) for x in res[0]["servicePrincipalName"]])
self.fail()
except LdbError as e77:
(num, _) = e77.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestcomputer,cn=computers," + self.base_dn)
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["dNSHostName", "sAMAccountName", "servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["dNSHostName"][0]), "testname2.testdom")
- self.assertEquals(str(res[0]["sAMAccountName"][0]), "testname2$")
+ self.assertEqual(str(res[0]["dNSHostName"][0]), "testname2.testdom")
+ self.assertEqual(str(res[0]["sAMAccountName"][0]), "testname2$")
self.assertTrue(len(res[0]["servicePrincipalName"]) == 3)
self.assertTrue("HOST/testname2" in [str(x) for x in res[0]["servicePrincipalName"]])
self.assertTrue("HOST/testname3" in [str(x) for x in res[0]["servicePrincipalName"]])
res = ldb.search("cn=ldaptestcomputer,cn=computers," + self.base_dn,
scope=SCOPE_BASE, attrs=["dNSHostName", "sAMAccountName", "servicePrincipalName"])
self.assertTrue(len(res) == 1)
- self.assertEquals(str(res[0]["dNSHostName"][0]), "testname3.testdom")
- self.assertEquals(str(res[0]["sAMAccountName"][0]), "testname2$")
+ self.assertEqual(str(res[0]["dNSHostName"][0]), "testname3.testdom")
+ self.assertEqual(str(res[0]["sAMAccountName"][0]), "testname2$")
self.assertTrue(len(res[0]["servicePrincipalName"]) == 3)
self.assertTrue("HOST/testname2" in [str(x) for x in res[0]["servicePrincipalName"]])
self.assertTrue("HOST/testname3" in [str(x) for x in res[0]["servicePrincipalName"]])
self.assertTrue(len(res) == 1)
self.assertTrue("description" in res[0])
self.assertTrue(len(res[0]["description"]) == 1)
- self.assertEquals(str(res[0]["description"][0]), "desc1")
+ self.assertEqual(str(res[0]["description"][0]), "desc1")
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e78:
(num, _) = e78.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.assertTrue(len(res) == 1)
self.assertTrue("description" in res[0])
self.assertTrue(len(res[0]["description"]) == 1)
- self.assertEquals(str(res[0]["description"][0]), "desc1")
+ self.assertEqual(str(res[0]["description"][0]), "desc1")
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.assertTrue(len(res) == 1)
self.assertTrue("description" in res[0])
self.assertTrue(len(res[0]["description"]) == 1)
- self.assertEquals(str(res[0]["description"][0]), "desc1")
+ self.assertEqual(str(res[0]["description"][0]), "desc1")
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e79:
(num, _) = e79.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e80:
(num, _) = e80.args
- self.assertEquals(num, ERR_NO_SUCH_ATTRIBUTE)
+ self.assertEqual(num, ERR_NO_SUCH_ATTRIBUTE)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e81:
(num, _) = e81.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e82:
(num, _) = e82.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.assertTrue(len(res) == 1)
self.assertTrue("description" in res[0])
self.assertTrue(len(res[0]["description"]) == 1)
- self.assertEquals(str(res[0]["description"][0]), "desc1")
+ self.assertEqual(str(res[0]["description"][0]), "desc1")
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.assertTrue(len(res) == 1)
self.assertTrue("description" in res[0])
self.assertTrue(len(res[0]["description"]) == 1)
- self.assertEquals(str(res[0]["description"][0]), "desc2")
+ self.assertEqual(str(res[0]["description"][0]), "desc2")
delete_force(self.ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e83:
(num, _) = e83.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
try:
self.ldb.add({
self.fail()
except LdbError as e84:
(num, _) = e84.args
- self.assertEquals(num, ERR_CONSTRAINT_VIOLATION)
+ self.assertEqual(num, ERR_CONSTRAINT_VIOLATION)
# We are able to set it to a valid "nTDSDSA" entry if the server is
# capable of handling the role
self.fail()
except LdbError as e85:
(num, _) = e85.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
m = Message()
m.dn = Dn(ldb, "cn=ldaptestgroup,cn=users," + self.base_dn)
self.fail()
except LdbError as e86:
(num, _) = e86.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
# We are able to set it to a valid "nTDSDSA" entry if the server is
# capable of handling the role
self.ldb.delete(pr_object[0] + "," + pr_object[1] + self.base_dn)
except LdbError as e7:
(num, _) = e7.args
- self.assertEquals(num, ERR_OTHER)
+ self.assertEqual(num, ERR_OTHER)
else:
self.fail("Deleted " + pr_object[0])
self.ldb_admin.search(base=class_dn, attrs=["name"])
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
break
ldif = """
res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
attrs=["sDRightsEffective"])
# user whould have no rights at all
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["sDRightsEffective"][0]), "0")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["sDRightsEffective"][0]), "0")
# give the user Write DACL and see what happens
mod = "(A;CI;WD;;;%s)" % str(user_sid)
self.sd_utils.dacl_add_ace(object_dn, mod)
res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
attrs=["sDRightsEffective"])
# user whould have DACL_SECURITY_INFORMATION
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["sDRightsEffective"][0]), ("%d") % SECINFO_DACL)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["sDRightsEffective"][0]), ("%d") % SECINFO_DACL)
# give the user Write Owners and see what happens
mod = "(A;CI;WO;;;%s)" % str(user_sid)
self.sd_utils.dacl_add_ace(object_dn, mod)
res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
attrs=["sDRightsEffective"])
# user whould have DACL_SECURITY_INFORMATION, OWNER_SECURITY_INFORMATION, GROUP_SECURITY_INFORMATION
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["sDRightsEffective"][0]), ("%d") % (SECINFO_DACL | SECINFO_GROUP | SECINFO_OWNER))
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["sDRightsEffective"][0]), ("%d") % (SECINFO_DACL | SECINFO_GROUP | SECINFO_OWNER))
# no way to grant security privilege bu adding ACE's so we use a memeber of Domain Admins
_ldb = self.get_ldb_connection("testuser_attr2", "samba123@")
res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
attrs=["sDRightsEffective"])
# user whould have DACL_SECURITY_INFORMATION, OWNER_SECURITY_INFORMATION, GROUP_SECURITY_INFORMATION
- self.assertEquals(len(res), 1)
- self.assertEquals(str(res[0]["sDRightsEffective"][0]),
+ self.assertEqual(len(res), 1)
+ self.assertEqual(str(res[0]["sDRightsEffective"][0]),
("%d") % (SECINFO_DACL | SECINFO_GROUP | SECINFO_OWNER | SECINFO_SACL))
def test_allowedChildClassesEffective(self):
res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
attrs=["allowedChildClassesEffective"])
# there should be no allowed child classes
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertFalse("allowedChildClassesEffective" in res[0].keys())
# give the user the right to create children of type user
mod = "(OA;CI;CC;bf967aba-0de6-11d0-a285-00aa003049e2;;%s)" % str(user_sid)
res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
attrs=["allowedChildClassesEffective"])
# allowedChildClassesEffective should only have one value, user
- self.assertEquals(len(res), 1)
- self.assertEquals(len(res[0]["allowedChildClassesEffective"]), 1)
- self.assertEquals(str(res[0]["allowedChildClassesEffective"][0]), "user")
+ self.assertEqual(len(res), 1)
+ self.assertEqual(len(res[0]["allowedChildClassesEffective"]), 1)
+ self.assertEqual(str(res[0]["allowedChildClassesEffective"][0]), "user")
def test_allowedAttributesEffective(self):
object_dn = "OU=test_domain_ou1," + self.base_dn
res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
attrs=["allowedAttributesEffective"])
# there should be no allowed attributes
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.assertFalse("allowedAttributesEffective" in res[0].keys())
# give the user the right to write displayName and managedBy
mod2 = "(OA;CI;WP;bf967953-0de6-11d0-a285-00aa003049e2;;%s)" % str(user_sid)
res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
attrs=["allowedAttributesEffective"])
# value should only contain user and managedBy
- self.assertEquals(len(res), 1)
- self.assertEquals(len(res[0]["allowedAttributesEffective"]), 2)
+ self.assertEqual(len(res), 1)
+ self.assertEqual(len(res[0]["allowedAttributesEffective"]), 2)
self.assertTrue(b"displayName" in res[0]["allowedAttributesEffective"])
self.assertTrue(b"managedBy" in res[0]["allowedAttributesEffective"])
print("unnormalised:", [x[attr][0] for x in res])
print("unnormalised: «%s»" % '» «'.join(str(x[attr][0])
for x in res))
- self.assertEquals(expected_order, received_order)
+ self.assertEqual(expected_order, received_order)
def _test_server_sort_binary(self):
for attr in self.binary_sorted_keys:
print(attr)
print(expected_order)
print(received_order)
- self.assertEquals(expected_order, received_order)
+ self.assertEqual(expected_order, received_order)
def _test_server_sort_us_english(self):
# Windows doesn't support many matching rules, but does allow
print("unnormalised: «%s»" % '» «'.join(str(x[attr][0])
for x in res))
- self.assertEquals(expected_order, received_order)
+ self.assertEqual(expected_order, received_order)
def _test_server_sort_different_attr(self):
print("Try with --elements=27 (or similar).")
print('-' * 72)
- self.assertEquals(expected_order, received_order)
+ self.assertEqual(expected_order, received_order)
for x in res:
if sort_attr in x:
self.fail('the search for %s should not return %s' %
self.base_dn = self.ldb.domain_dn()
res = self.ldb.search("", scope=ldb.SCOPE_BASE, attrs=["tokenGroups"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.user_sid_dn = "<SID=%s>" % str(ndr_unpack(samba.dcerpc.security.dom_sid, res[0]["tokenGroups"][0]))
self.fail(msg="This test is only valid on ldap")
res = self.ldb.search("", scope=ldb.SCOPE_BASE, attrs=["tokenGroups"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
print("Getting tokenGroups from rootDSE")
tokengroups = []
def test_dn_tokenGroups(self):
print("Getting tokenGroups from user DN")
res = self.ldb.search(self.user_sid_dn, scope=ldb.SCOPE_BASE, attrs=["tokenGroups"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
dn_tokengroups = []
for sid in res[0]['tokenGroups']:
self.ldb = self.get_ldb_connection(self.test_user, self.test_user_pass)
res = self.ldb.search("", scope=ldb.SCOPE_BASE, attrs=["tokenGroups"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.user_sid = ndr_unpack(samba.dcerpc.security.dom_sid, res[0]["tokenGroups"][0])
self.user_sid_dn = "<SID=%s>" % str(self.user_sid)
res = self.ldb.search(self.user_sid_dn, scope=ldb.SCOPE_BASE, attrs=[])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
self.test_user_dn = res[0].dn
self.fail(msg="This test is only valid on ldap")
res = self.ldb.search("", scope=ldb.SCOPE_BASE, attrs=["tokenGroups"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
print("Getting tokenGroups from rootDSE")
tokengroups = []
def test_dn_tokenGroups(self):
print("Getting tokenGroups from user DN")
res = self.ldb.search(self.user_sid_dn, scope=ldb.SCOPE_BASE, attrs=["tokenGroups"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
dn_tokengroups = []
for sid in res[0]['tokenGroups']:
tokenGroupsSet = set()
res = self.ldb.search(self.user_sid_dn, scope=ldb.SCOPE_BASE, attrs=["tokenGroups"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
dn_tokengroups = []
for sid in res[0]['tokenGroups']:
tokenGroupsSet = set()
res = self.ldb.search(self.user_sid_dn, scope=ldb.SCOPE_BASE, attrs=["tokenGroupsGlobalAndUniversal"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
dn_tokengroups = []
for sid in res[0]['tokenGroupsGlobalAndUniversal']:
res = self.samdb.search(base="<GUID=%s>" % self.GUID_string(guid),
scope=SCOPE_BASE, attrs=attrs,
controls=["show_deleted:1"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
return res[0]
def search_dn(self, dn):
base=dn,
scope=SCOPE_BASE,
controls=["show_recycled:1"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
return res[0]
def _create_object(self, msg):
for o in repl.ctr.array:
e = expected[i]
(attid, version) = e
- self.assertEquals(attid, o.attid,
+ self.assertEqual(attid, o.attid,
"(LDAP) Wrong attid "
"for expected value %d, wanted 0x%08x got 0x%08x, "
"repl: \n%s"
% (i, attid, o.attid, ndr_print(repl)))
# Allow version to be skipped when it does not matter
if version is not None:
- self.assertEquals(o.version, version,
+ self.assertEqual(o.version, version,
"(LDAP) Wrong version for expected value %d, "
"attid 0x%08x, "
"wanted %d got %d, repl: \n%s"
self.samdb.modify(msg)
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
+ self.assertEqual(num, ERR_ATTRIBUTE_OR_VALUE_EXISTS)
def test_undelete(self):
print("Testing standard undelete operation")
self.fail()
except LdbError as e1:
(num, _) = e1.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
try:
self.samdb.rename(str(objDeleted1.dn), usr1, ["show_deleted:1"])
self.fail()
except LdbError as e2:
(num, _) = e2.args
- self.assertEquals(num, ERR_UNWILLING_TO_PERFORM)
+ self.assertEqual(num, ERR_UNWILLING_TO_PERFORM)
def test_undelete_with_mod(self):
print("Testing standard undelete operation with modification of additional attributes")
self.fail()
except LdbError as e3:
(num, _) = e3.args
- self.assertEquals(num, ERR_ENTRY_ALREADY_EXISTS)
+ self.assertEqual(num, ERR_ENTRY_ALREADY_EXISTS)
def test_undelete_cross_nc(self):
print("Cross NC undelete")
self.fail()
except LdbError as e4:
(num, _) = e4.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
# try to undelete from config to base dn
try:
self.restore_deleted_object(self.samdb, objDeleted2.dn, c4)
self.fail()
except LdbError as e5:
(num, _) = e5.args
- self.assertEquals(num, ERR_OPERATIONS_ERROR)
+ self.assertEqual(num, ERR_OPERATIONS_ERROR)
# assert undeletion will work in same nc
self.restore_deleted_object(self.samdb, objDeleted1.dn, c4)
self.restore_deleted_object(self.samdb, objDeleted2.dn, c3)
ldb.delete(dn, ["relax:0"])
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
def setUp(self):
super(UrgentReplicationTests, self).setUp()
# urgent replication should be enabled when creation
res = self.ldb.load_partition_usn("cn=Configuration," + self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
# urgent replication should NOT be enabled when modifying
m = Message()
# urgent replication should be enabled when deleting
self.delete_force(self.ldb, "cn=NTDS Settings test,cn=test server,cn=Servers,cn=Default-First-Site-Name,cn=Sites,cn=Configuration," + self.base_dn)
res = self.ldb.load_partition_usn("cn=Configuration," + self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
self.delete_force(self.ldb, "cn=test server,cn=Servers,cn=Default-First-Site-Name,cn=Sites,cn=Configuration," + self.base_dn)
# urgent replication should be enabled when creating
res = self.ldb.load_partition_usn("cn=Configuration," + self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
# urgent replication should NOT be enabled when modifying
m = Message()
# urgent replication should be enabled when deleting
self.delete_force(self.ldb, "cn=test crossRef,CN=Partitions,CN=Configuration," + self.base_dn)
res = self.ldb.load_partition_usn("cn=Configuration," + self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
def test_attributeSchema_object(self):
"""Test if the urgent replication is activated when handling an attributeSchema object"""
# urgent replication should be enabled when creating
res = self.ldb.load_partition_usn("cn=Schema,cn=Configuration," + self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
# urgent replication should be enabled when modifying
m = Message()
"lDAPDisplayName")
self.ldb.modify(m)
res = self.ldb.load_partition_usn("cn=Schema,cn=Configuration," + self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
def test_classSchema_object(self):
"""Test if the urgent replication is activated when handling a classSchema object."""
# urgent replication should be enabled when creating
res = self.ldb.load_partition_usn("cn=Schema,cn=Configuration," + self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
except LdbError:
print("Not testing urgent replication when creating classSchema object ...\n")
"lDAPDisplayName")
self.ldb.modify(m)
res = self.ldb.load_partition_usn("cn=Schema,cn=Configuration," + self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
def test_secret_object(self):
"""Test if the urgent replication is activated when handling a secret object."""
# urgent replication should be enabled when creating
res = self.ldb.load_partition_usn(self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
# urgent replication should be enabled when modifying
m = Message()
"currentValue")
self.ldb.modify(m)
res = self.ldb.load_partition_usn(self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
# urgent replication should NOT be enabled when deleting
self.delete_force(self.ldb, "cn=test secret,cn=System," + self.base_dn)
# urgent replication should be enabled when creating
res = self.ldb.load_partition_usn(self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
# urgent replication should be enabled when modifying
m = Message()
"systemFlags")
self.ldb.modify(m)
res = self.ldb.load_partition_usn(self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
# urgent replication should NOT be enabled when deleting
self.delete_force(self.ldb, "CN=RID Manager test,CN=System," + self.base_dn)
"userAccountControl")
self.ldb.modify(m)
res = self.ldb.load_partition_usn(self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
# urgent replication should be enabled when modifying lockoutTime
m = Message()
"lockoutTime")
self.ldb.modify(m)
res = self.ldb.load_partition_usn(self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
# urgent replication should be enabled when modifying pwdLastSet
m = Message()
"pwdLastSet")
self.ldb.modify(m)
res = self.ldb.load_partition_usn(self.base_dn)
- self.assertEquals(res["uSNHighest"], res["uSNUrgent"])
+ self.assertEqual(res["uSNHighest"], res["uSNUrgent"])
# urgent replication should NOT be enabled when modifying a not-urgent
# attribute
print("start %d end %d" % (start, end))
print("expected: %s" % expected_results)
print("got : %s" % results)
- self.assertEquals(expected_results, results)
+ self.assertEqual(expected_results, results)
def test_server_vlv_with_cookie(self):
attrs = [x for x in self.users[0].keys() if x not in
expected_results = expected_order[start: end]
- self.assertEquals(expected_results, results)
+ self.assertEqual(expected_results, results)
def test_vlv_gte_with_expression(self):
"""What happens when we run the VLV with an expression?"""
if expected_results != results:
print("attr %s before %d after %d offset %d" %
(attr, before, after, offset))
- self.assertEquals(expected_results, results)
+ self.assertEqual(expected_results, results)
n = len(self.users)
if random.random() < 0.1 + (n < 5) * 0.05:
controls=[sort_control, vlv_search])
results = [x[attr][0].upper() for x in res]
- #self.assertEquals(expected_order, results)
+ #self.assertEqual(expected_order, results)
dn_order = [str(x['dn']) for x in res]
values = results[:]
dn_expected = dn_order[offset - before - 1:
offset + after]
- self.assertEquals(dn_expected, dn_results)
+ self.assertEqual(dn_expected, dn_results)
results = [x[attr][0].upper() for x in res]
expected_results = expected_order[start: end]
- self.assertEquals(expected_results, results)
+ self.assertEqual(expected_results, results)
def test_server_vlv_gte_no_cookie(self):
attrs = [x for x in self.users[0].keys() if x not in
print("\nattr %s offset %d before %d "
"after %d gte %s" %
(attr, offset, before, after, gte))
- self.assertEquals(expected_results, results)
+ self.assertEqual(expected_results, results)
def test_multiple_searches(self):
"""The maximum number of concurrent vlv searches per connection is
drsuapi.DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
drsuapi.DRSUAPI_DS_NAME_FORMAT_GUID)
- self.assertEquals(ctr.count, 1)
- self.assertEquals(ctr.array[0].status,
+ self.assertEqual(ctr.count, 1)
+ self.assertEqual(ctr.array[0].status,
drsuapi.DRSUAPI_DS_NAME_STATUS_OK)
user_guid = ctr.array[0].result_name
drsuapi.DRSUAPI_DS_NAME_FORMAT_GUID,
name_format)
- self.assertEquals(ctr.count, 1)
- self.assertEquals(ctr.array[0].status,
+ self.assertEqual(ctr.count, 1)
+ self.assertEqual(ctr.array[0].status,
drsuapi.DRSUAPI_DS_NAME_STATUS_OK,
"Expected 0, got %s, desired format is %s"
% (ctr.array[0].status, name_format))
name_format,
drsuapi.DRSUAPI_DS_NAME_FORMAT_GUID)
- self.assertEquals(ctr.count, 1)
- self.assertEquals(ctr.array[0].status,
+ self.assertEqual(ctr.count, 1)
+ self.assertEqual(ctr.array[0].status,
drsuapi.DRSUAPI_DS_NAME_STATUS_OK,
"Expected 0, got %s, offered format is %s"
% (ctr.array[0].status, name_format))
drsuapi.DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
drsuapi.DRSUAPI_DS_NAME_FORMAT_GUID)
- self.assertEquals(ctr.count, 1)
- self.assertEquals(ctr.array[0].status,
+ self.assertEqual(ctr.count, 1)
+ self.assertEqual(ctr.array[0].status,
drsuapi.DRSUAPI_DS_NAME_STATUS_OK)
user_guid = ctr.array[0].result_name
drsuapi.DRSUAPI_DS_NAME_FORMAT_GUID,
drsuapi.DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL)
- self.assertEquals(ctr.count, 1)
- self.assertEquals(ctr.array[0].status,
+ self.assertEqual(ctr.count, 1)
+ self.assertEqual(ctr.array[0].status,
drsuapi.DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE)
self.ldb_dc1.delete(user)
drsuapi.DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
drsuapi.DRSUAPI_DS_NAME_FORMAT_GUID)
- self.assertEquals(ctr.count, 1)
- self.assertEquals(ctr.array[0].status,
+ self.assertEqual(ctr.count, 1)
+ self.assertEqual(ctr.array[0].status,
drsuapi.DRSUAPI_DS_NAME_STATUS_OK)
user_guid = ctr.array[0].result_name
drsuapi.DRSUAPI_DS_NAME_FORMAT_GUID,
drsuapi.DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL)
- self.assertEquals(ctr.count, 1)
- self.assertEquals(ctr.array[0].status,
+ self.assertEqual(ctr.count, 1)
+ self.assertEqual(ctr.array[0].status,
drsuapi.DRSUAPI_DS_NAME_STATUS_NOT_FOUND)
self.ldb_dc1.delete(user)
res = sam_ldb.search(base=self.domain_dn,
expression=expression,
controls=["show_deleted:1"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
user_cur = res[0]
# Deleted Object base DN
dodn = self._deleted_objects_dn(sam_ldb)
name_orig = str(obj_orig["name"][0])
name_cur = str(user_cur["name"][0])
if is_deleted:
- self.assertEquals(str(user_cur["isDeleted"][0]), "TRUE")
+ self.assertEqual(str(user_cur["isDeleted"][0]), "TRUE")
self.assertFalse("objectCategory" in user_cur)
self.assertFalse("sAMAccountType" in user_cur)
self.assertFalse("description" in user_cur)
self.assertFalse("member" in user_cur)
self.assertTrue(dodn in str(user_cur["dn"]),
"User %s is deleted but it is not located under %s (found at %s)!" % (name_orig, dodn, user_cur["dn"]))
- self.assertEquals(name_cur, name_orig + "\nDEL:" + guid_str)
- self.assertEquals(name_cur, user_cur.dn.get_rdn_value())
- self.assertEquals(cn_cur, cn_orig + "\nDEL:" + guid_str)
- self.assertEquals(name_cur, cn_cur)
+ self.assertEqual(name_cur, name_orig + "\nDEL:" + guid_str)
+ self.assertEqual(name_cur, user_cur.dn.get_rdn_value())
+ self.assertEqual(cn_cur, cn_orig + "\nDEL:" + guid_str)
+ self.assertEqual(name_cur, cn_cur)
else:
self.assertFalse("isDeleted" in user_cur)
- self.assertEquals(name_cur, name_orig)
- self.assertEquals(name_cur, user_cur.dn.get_rdn_value())
- self.assertEquals(cn_cur, cn_orig)
- self.assertEquals(name_cur, cn_cur)
- self.assertEquals(obj_orig["dn"], user_cur["dn"])
+ self.assertEqual(name_cur, name_orig)
+ self.assertEqual(name_cur, user_cur.dn.get_rdn_value())
+ self.assertEqual(cn_cur, cn_orig)
+ self.assertEqual(name_cur, cn_cur)
+ self.assertEqual(obj_orig["dn"], user_cur["dn"])
self.assertTrue(dodn not in str(user_cur["dn"]))
return user_cur
ldb_res = self.ldb_dc1.search(base=self.domain_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.domain_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
res = sam_ldb.search(base=wkdn,
scope=SCOPE_BASE,
controls=["show_deleted:1"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
return str(res[0]["dn"])
def _lost_and_found_dn(self, sam_ldb, nc):
wkdn = "<WKGUID=%s,%s>" % (dsdb.DS_GUID_LOSTANDFOUND_CONTAINER, nc)
res = sam_ldb.search(base=wkdn,
scope=SCOPE_BASE)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
return str(res[0]["dn"])
def _make_obj_name(self, prefix):
(result, out, err) = self.runsubcmd(*samba_tool_cmdline)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
def _enable_inbound_repl(self, DC):
# make base command line
samba_tool_cmd += [DC, "--dsa-option=-DISABLE_INBOUND_REPL"]
(result, out, err) = self.runsubcmd(*samba_tool_cmd)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
def _disable_inbound_repl(self, DC):
# make base command line
samba_tool_cmd += [DC, "--dsa-option=+DISABLE_INBOUND_REPL"]
(result, out, err) = self.runsubcmd(*samba_tool_cmd)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
def _enable_all_repl(self, DC):
self._enable_inbound_repl(DC)
samba_tool_cmd += [DC, "--dsa-option=-DISABLE_OUTBOUND_REPL"]
(result, out, err) = self.runsubcmd(*samba_tool_cmd)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
def _disable_all_repl(self, DC):
self._disable_inbound_repl(DC)
samba_tool_cmd += [DC, "--dsa-option=+DISABLE_OUTBOUND_REPL"]
(result, out, err) = self.runsubcmd(*samba_tool_cmd)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
def _get_highest_hwm_utdv(self, ldb_conn):
res = ldb_conn.search("", scope=ldb.SCOPE_BASE, attrs=["highestCommittedUSN"])
cmd_line_auth)
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
if not noop:
self.assertTrue("FSMO transfer of '%s' role successful" % role in out)
else:
self.fail("Expected DsGetNCChanges to fail with WERR_DS_CANT_FIND_EXPECTED_NC")
except WERRORError as e1:
(enum, estr) = e1.args
- self.assertEquals(enum, werror.WERR_DS_CANT_FIND_EXPECTED_NC)
+ self.assertEqual(enum, werror.WERR_DS_CANT_FIND_EXPECTED_NC)
def test_link_utdv_hwm(self):
"""Test verify the DRS_GET_ANC behavior."""
"""Adds an OU object"""
self.test_ldb_dc.add({"dn": dn, "objectclass": objectclass})
res = self.test_ldb_dc.search(base=dn, scope=SCOPE_BASE)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
def modify_object(self, dn, attr, value):
"""Modifies an object's USN by adding an attribute value to it"""
for o in repl.ctr.array:
e = expected[i]
(attid, orig_dsa, version) = e
- self.assertEquals(attid, o.attid,
+ self.assertEqual(attid, o.attid,
"(LDAP) Wrong attid "
"for expected value %d, wanted 0x%08x got 0x%08x"
% (i, attid, o.attid))
- self.assertEquals(o.originating_invocation_id,
+ self.assertEqual(o.originating_invocation_id,
misc.GUID(orig_dsa),
"(LDAP) Wrong originating_invocation_id "
"for expected value %d, attid 0x%08x, wanted %s got %s"
o.originating_invocation_id))
# Allow version to be skipped when it does not matter
if version is not None:
- self.assertEquals(o.version, version,
+ self.assertEqual(o.version, version,
"(LDAP) Wrong version for expected value %d, "
"attid 0x%08x, "
"wanted %d got %d"
e = expected[i]
(attid, orig_dsa, version) = e
- self.assertEquals(attid, drs_attid.attid,
+ self.assertEqual(attid, drs_attid.attid,
"(DRS) Wrong attid "
"for expected value %d, wanted 0x%08x got 0x%08x"
% (i, attid, drs_attid.attid))
- self.assertEquals(o.originating_invocation_id,
+ self.assertEqual(o.originating_invocation_id,
misc.GUID(orig_dsa),
"(DRS) Wrong originating_invocation_id "
"for expected value %d, attid 0x%08x, wanted %s got %s"
o.originating_invocation_id))
# Allow version to be skipped when it does not matter
if version is not None:
- self.assertEquals(o.version, version,
+ self.assertEqual(o.version, version,
"(DRS) Wrong version for expected value %d, "
"attid 0x%08x, "
"wanted %d got %d"
controls=["show_deleted:1"],
attrs=["*", "parentGUID",
"replPropertyMetaData"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
user_cur = res[0]
rdn_orig = str(obj_orig[user_cur.dn.get_rdn_name()][0])
rdn_cur = str(user_cur[user_cur.dn.get_rdn_name()][0])
# now check properties of the user
if is_deleted:
self.assertTrue("isDeleted" in user_cur)
- self.assertEquals(rdn_cur.split('\n')[0], rdn_orig)
- self.assertEquals(name_cur.split('\n')[0], name_orig)
- self.assertEquals(dn_cur.get_rdn_value().split('\n')[0],
+ self.assertEqual(rdn_cur.split('\n')[0], rdn_orig)
+ self.assertEqual(name_cur.split('\n')[0], name_orig)
+ self.assertEqual(dn_cur.get_rdn_value().split('\n')[0],
dn_orig.get_rdn_value())
self.assertEqual(name_cur, rdn_cur)
else:
self.assertFalse("isDeleted" in user_cur)
- self.assertEquals(rdn_cur, rdn_orig)
- self.assertEquals(name_cur, name_orig)
- self.assertEquals(dn_cur, dn_orig)
+ self.assertEqual(rdn_cur, rdn_orig)
+ self.assertEqual(name_cur, name_orig)
+ self.assertEqual(dn_cur, dn_orig)
self.assertEqual(name_cur, rdn_cur)
parent_cur = user_cur["parentGUID"][0]
try:
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
moved_metadata = [
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 0)
+ self.assertEqual(len(ldb_res), 0)
# delete user on DC1
self.ldb_dc1.delete('<GUID=%s>' % self._GUID_string(user_orig["objectGUID"][0]))
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.ou1_dn,
scope=SCOPE_BASE,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
ou_orig = ldb_res[0]
ou_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=new_dn,
scope=SCOPE_BASE,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
ou_moved_orig = ldb_res[0]
ou_moved_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.ou1_dn,
scope=SCOPE_BASE,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
ou_orig = ldb_res[0]
ou_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=new_dn,
scope=SCOPE_BASE,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
ou_moved_orig = ldb_res[0]
ou_moved_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.ou1_dn,
scope=SCOPE_BASE,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
ou_orig = ldb_res[0]
ou_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=new_dn,
scope=SCOPE_BASE,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
ou_moved_orig = ldb_res[0]
ou_moved_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.ou1_dn,
scope=SCOPE_BASE,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
ou_orig = ldb_res[0]
ou_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=new_dn,
scope=SCOPE_BASE,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
ou_moved_orig = ldb_res[0]
ou_moved_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.ou1_dn,
scope=SCOPE_BASE,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
ou_orig = ldb_res[0]
ou_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.ou1_dn,
scope=SCOPE_BASE,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
ou_orig = ldb_res[0]
ou_dn = ldb_res[0]["dn"]
res = sam_ldb.search(base='<GUID=%s>' % guid_str,
controls=["show_deleted:1"],
attrs=["*", "parentGUID"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
user_cur = res[0]
cn_orig = str(obj_orig["cn"][0])
cn_cur = str(user_cur["cn"][0])
# now check properties of the user
if is_deleted:
self.assertTrue("isDeleted" in user_cur)
- self.assertEquals(cn_cur.split('\n')[0], cn_orig)
- self.assertEquals(name_cur.split('\n')[0], name_orig)
- self.assertEquals(dn_cur.get_rdn_value().split('\n')[0],
+ self.assertEqual(cn_cur.split('\n')[0], cn_orig)
+ self.assertEqual(name_cur.split('\n')[0], name_orig)
+ self.assertEqual(dn_cur.get_rdn_value().split('\n')[0],
dn_orig.get_rdn_value())
self.assertEqual(name_cur, cn_cur)
else:
self.assertFalse("isDeleted" in user_cur)
- self.assertEquals(cn_cur, cn_orig)
- self.assertEquals(name_cur, name_orig)
- self.assertEquals(dn_cur, dn_orig)
+ self.assertEqual(cn_cur, cn_orig)
+ self.assertEqual(name_cur, name_orig)
+ self.assertEqual(dn_cur, dn_orig)
self.assertEqual(name_cur, cn_cur)
self.assertEqual(name_cur, user_cur.dn.get_rdn_value())
ldb_res = self.ldb_dc1.search(base=self.ou1_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.ou2_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.ou1_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=new_dn3,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.ou1_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.ou1_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=new_dn3,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
# check user info on DC2 - should be valid user
user_cur = self._check_obj(sam_ldb=self.ldb_dc2, obj_orig=user_moved_orig, is_deleted=False)
- self.assertEquals(user_cur["parentGUID"], user_moved_orig["parentGUID"])
+ self.assertEqual(user_cur["parentGUID"], user_moved_orig["parentGUID"])
# delete user on DC1
self.ldb_dc1.delete('<GUID=%s>' % self._GUID_string(user_orig["objectGUID"][0]))
ldb_res = self.ldb_dc1.search(base=self.ou1_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.ou2_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
self._net_drs_replicate(DC=self.dnsname_dc2, fromDC=self.dnsname_dc1, forced=True)
# check user info on DC2 - should be valid user
user_cur = self._check_obj(sam_ldb=self.ldb_dc2, obj_orig=user_moved_orig, is_deleted=False)
- self.assertEquals(user_cur["parentGUID"][0], user_moved_orig["parentGUID"][0])
+ self.assertEqual(user_cur["parentGUID"][0], user_moved_orig["parentGUID"][0])
# delete user on DC1
self.ldb_dc1.delete('<GUID=%s>' % self._GUID_string(user_orig["objectGUID"][0]))
ldb_res = self.ldb_dc1.search(base=self.ou1_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
ldb_res = self.ldb_dc1.search(base=self.ou2_dn,
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username)
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved_orig = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
# check user info on DC2 - should be valid user
user_cur = self._check_obj(sam_ldb=self.ldb_dc2, obj_orig=user_orig, is_deleted=False)
- self.assertEquals(user_cur["parentGUID"], user_orig["parentGUID"])
+ self.assertEqual(user_cur["parentGUID"], user_orig["parentGUID"])
# delete user on DC1
self.ldb_dc1.delete('<GUID=%s>' % self._GUID_string(user_orig["objectGUID"][0]))
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
# check user info on DC2 - should be valid user
user_cur = self._check_obj(sam_ldb=self.ldb_dc2, obj_orig=user_moved, is_deleted=False)
- self.assertEquals(user_cur["parentGUID"], user_moved["parentGUID"])
+ self.assertEqual(user_cur["parentGUID"], user_moved["parentGUID"])
# delete user on DC1
self.ldb_dc1.delete('<GUID=%s>' % self._GUID_string(user_orig["objectGUID"][0]))
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
# check user info on DC2 - should be under the OU2 from DC1
user_cur = self._check_obj(sam_ldb=self.ldb_dc2, obj_orig=user_moved, is_deleted=False)
- self.assertEquals(user_cur["parentGUID"], user_moved["parentGUID"])
+ self.assertEqual(user_cur["parentGUID"], user_moved["parentGUID"])
# delete user on DC1
self.ldb_dc1.delete('<GUID=%s>' % self._GUID_string(user_orig["objectGUID"][0]))
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_orig = ldb_res[0]
user_dn = ldb_res[0]["dn"]
scope=SCOPE_SUBTREE,
expression="(samAccountName=%s)" % username,
attrs=["*", "parentGUID"])
- self.assertEquals(len(ldb_res), 1)
+ self.assertEqual(len(ldb_res), 1)
user_moved = ldb_res[0]
user_moved_dn = ldb_res[0]["dn"]
# check user info on DC2 - should be under the OU2 from DC1
user_cur = self._check_obj(sam_ldb=self.ldb_dc2, obj_orig=user_moved, is_deleted=False)
- self.assertEquals(user_cur["parentGUID"], user_moved["parentGUID"])
+ self.assertEqual(user_cur["parentGUID"], user_moved["parentGUID"])
# delete user on DC1
self.ldb_dc1.delete('<GUID=%s>' % self._GUID_string(user_orig["objectGUID"][0]))
self.fail("Successfully replicated secrets to an RODC that shouldn't have been replicated.")
except WERRORError as e:
(enum, estr) = e.args
- self.assertEquals(enum, 8630) # ERROR_DS_DRA_SECRETS_DENIED
+ self.assertEqual(enum, 8630) # ERROR_DS_DRA_SECRETS_DENIED
# send the same request again and we should get the same response
try:
self.fail("Successfully replicated secrets to an RODC that shouldn't have been replicated.")
except WERRORError as e1:
(enum, estr) = e1.args
- self.assertEquals(enum, 8630) # ERROR_DS_DRA_SECRETS_DENIED
+ self.assertEqual(enum, 8630) # ERROR_DS_DRA_SECRETS_DENIED
# Retry with Administrator credentials, ignores password replication groups
(level, ctr) = self.drs.DsGetNCChanges(self.drs_handle, 10, req10)
self.fail("Successfully replicated secrets to an RODC that shouldn't have been replicated.")
except WERRORError as e3:
(enum, estr) = e3.args
- self.assertEquals(enum, 8630) # ERROR_DS_DRA_SECRETS_DENIED
+ self.assertEqual(enum, 8630) # ERROR_DS_DRA_SECRETS_DENIED
req10 = self._getnc_req10(dest_dsa=str(self.rodc_ctx.ntds_guid),
invocation_id=self.ldb_dc1.get_invocation_id(),
self.fail("Successfully replicated secrets to an RODC that shouldn't have been replicated.")
except WERRORError as e4:
(enum, estr) = e4.args
- self.assertEquals(enum, 8630) # ERROR_DS_DRA_SECRETS_DENIED
+ self.assertEqual(enum, 8630) # ERROR_DS_DRA_SECRETS_DENIED
def test_msDSRevealedUsers_local_deny_allow(self):
"""
self.fail("Successfully replicated secrets to an RODC that shouldn't have been replicated.")
except WERRORError as e5:
(enum, estr) = e5.args
- self.assertEquals(enum, 8630) # ERROR_DS_DRA_SECRETS_DENIED
+ self.assertEqual(enum, 8630) # ERROR_DS_DRA_SECRETS_DENIED
m = ldb.Message()
m.dn = ldb.Dn(self.ldb_dc1, self.computer_dn)
self.fail("Successfully replicated secrets to an RODC that shouldn't have been replicated.")
except WERRORError as e6:
(enum, estr) = e6.args
- self.assertEquals(enum, 8630) # ERROR_DS_DRA_SECRETS_DENIED
+ self.assertEqual(enum, 8630) # ERROR_DS_DRA_SECRETS_DENIED
def _assert_in_revealed_users(self, user_dn, attrlist):
res = self.ldb_dc1.search(scope=ldb.SCOPE_BASE, base=self.computer_dn,
packed_attrs.append(dsdb_dn.get_bytes())
actual_attrids.append(metadata.attid)
- self.assertEquals(sorted(actual_attrids), sorted(attrlist))
+ self.assertEqual(sorted(actual_attrids), sorted(attrlist))
return (packed_attrs, unpacked_attrs)
def _assert_attrlist_changed(self, list_1, list_2, changed_attributes, num_changes=1, expected_new_usn=True):
for i in range(len(list_2)):
- self.assertEquals(list_1[i].attid, list_2[i].attid)
- self.assertEquals(list_1[i].originating_invocation_id, list_2[i].originating_invocation_id)
- self.assertEquals(list_1[i].version + num_changes, list_2[i].version)
+ self.assertEqual(list_1[i].attid, list_2[i].attid)
+ self.assertEqual(list_1[i].originating_invocation_id, list_2[i].originating_invocation_id)
+ self.assertEqual(list_1[i].version + num_changes, list_2[i].version)
if expected_new_usn:
self.assertTrue(list_1[i].originating_usn < list_2[i].originating_usn)
self.assertTrue(list_1[i].local_usn < list_2[i].local_usn)
else:
- self.assertEquals(list_1[i].originating_usn, list_2[i].originating_usn)
- self.assertEquals(list_1[i].local_usn, list_2[i].local_usn)
+ self.assertEqual(list_1[i].originating_usn, list_2[i].originating_usn)
+ self.assertEqual(list_1[i].local_usn, list_2[i].local_usn)
if list_1[i].attid in changed_attributes:
# We do the changes too quickly, so unless we put sleeps
pass
#self.assertTrue(list_1[i].originating_change_time < list_2[i].originating_change_time)
else:
- self.assertEquals(list_1[i].originating_change_time, list_2[i].originating_change_time)
+ self.assertEqual(list_1[i].originating_change_time, list_2[i].originating_change_time)
def _create_rodc(self, ctx):
ctx.nc_list = [ctx.base_dn, ctx.config_dn, ctx.schema_dn]
res_dc1 = self.ldb_dc1.search(base=obj_dn,
scope=SCOPE_BASE,
attrs=["*"])
- self.assertEquals(len(res_dc1), 1,
+ self.assertEqual(len(res_dc1), 1,
"%s doesn't exists on %s" % (obj_dn, self.dnsname_dc1))
try:
res_dc2 = self.ldb_dc2.search(base=obj_dn,
if enum == ERR_NO_SUCH_OBJECT:
self.fail("%s doesn't exists on %s" % (obj_dn, self.dnsname_dc2))
raise
- self.assertEquals(len(res_dc2), 1,
+ self.assertEqual(len(res_dc2), 1,
"%s doesn't exists on %s" % (obj_dn, self.dnsname_dc2))
def test_class(self):
self.assertIn(self.mod_inherits_as,
self.sd_utils_dc1.get_sd_as_sddl(dn))
- self.assertEquals(self.sd_utils_dc1.get_sd_as_sddl(dn),
+ self.assertEqual(self.sd_utils_dc1.get_sd_as_sddl(dn),
self.sd_utils_dc2.get_sd_as_sddl(dn))
def test_acl_inheirt_new_object(self):
self.assertIn(self.mod_inherits_as,
self.sd_utils_dc1.get_sd_as_sddl(dn))
- self.assertEquals(self.sd_utils_dc1.get_sd_as_sddl(dn),
+ self.assertEqual(self.sd_utils_dc1.get_sd_as_sddl(dn),
self.sd_utils_dc2.get_sd_as_sddl(dn))
def test_acl_inherit_existing_object(self):
self.assertIn(self.mod_inherits_as,
self.sd_utils_dc1.get_sd_as_sddl(dn))
- self.assertEquals(self.sd_utils_dc1.get_sd_as_sddl(dn),
+ self.assertEqual(self.sd_utils_dc1.get_sd_as_sddl(dn),
self.sd_utils_dc2.get_sd_as_sddl(dn))
def test_acl_inheirt_existing_object_1_pass(self):
self.assertIn(self.mod_inherits_as,
self.sd_utils_dc1.get_sd_as_sddl(dn))
- self.assertEquals(self.sd_utils_dc1.get_sd_as_sddl(dn),
+ self.assertEqual(self.sd_utils_dc1.get_sd_as_sddl(dn),
self.sd_utils_dc2.get_sd_as_sddl(dn))
def test_acl_inheirt_renamed_object(self):
# Confirm inherited ACLs are identical and were inherited
self.assertIn(self.mod_inherits_as,
self.sd_utils_dc1.get_sd_as_sddl(sub_ou_dn))
- self.assertEquals(self.sd_utils_dc1.get_sd_as_sddl(sub_ou_dn),
+ self.assertEqual(self.sd_utils_dc1.get_sd_as_sddl(sub_ou_dn),
self.sd_utils_dc2.get_sd_as_sddl(sub_ou_dn))
# Confirm set ACLs (on l3 ) are identical and were inherited
self.assertIn(self.mod_becomes,
self.sd_utils_dc2.get_sd_as_sddl(sub3_ou_dn_final))
- self.assertEquals(self.sd_utils_dc1.get_sd_as_sddl(sub3_ou_dn_final),
+ self.assertEqual(self.sd_utils_dc1.get_sd_as_sddl(sub3_ou_dn_final),
self.sd_utils_dc2.get_sd_as_sddl(sub3_ou_dn_final))
# Confirm inherited ACLs (from l3 to l4) are identical
# and where inherited
self.assertIn(self.mod_inherits_as,
self.sd_utils_dc1.get_sd_as_sddl(sub4_ou_dn_final))
- self.assertEquals(self.sd_utils_dc1.get_sd_as_sddl(sub4_ou_dn_final),
+ self.assertEqual(self.sd_utils_dc1.get_sd_as_sddl(sub4_ou_dn_final),
self.sd_utils_dc2.get_sd_as_sddl(sub4_ou_dn_final))
for child in children:
self.assertIn(self.mod_inherits_as,
self.sd_utils_dc2.get_sd_as_sddl(child.dn))
- self.assertEquals(self.sd_utils_dc1.get_sd_as_sddl(sub_ou_dn),
+ self.assertEqual(self.sd_utils_dc1.get_sd_as_sddl(sub_ou_dn),
self.sd_utils_dc2.get_sd_as_sddl(child.dn))
# Replicate back
for child in children:
self.assertIn(self.mod_inherits_as,
self.sd_utils_dc1.get_sd_as_sddl(child.dn))
- self.assertEquals(self.sd_utils_dc1.get_sd_as_sddl(child.dn),
+ self.assertEqual(self.sd_utils_dc1.get_sd_as_sddl(child.dn),
self.sd_utils_dc2.get_sd_as_sddl(child.dn))
self.ldb_dc2.delete(dn, ["tree_delete:1"])
except LdbError as e:
(num, _) = e.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
try:
self.ldb_dc1.delete(dn, ["tree_delete:1"])
except LdbError as e1:
(num, _) = e1.args
- self.assertEquals(num, ERR_NO_SUCH_OBJECT)
+ self.assertEqual(num, ERR_NO_SUCH_OBJECT)
def _cleanup_object(self, guid):
"""Cleans up a test object, if it still exists"""
res = sam_ldb.search(base='<GUID=%s>' % guid,
controls=["show_deleted:1"],
attrs=["isDeleted", "objectCategory", "ou"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
ou_cur = res[0]
# Deleted Object base DN
dodn = self._deleted_objects_dn(sam_ldb)
# now check properties of the user
name_cur = ou_cur["ou"][0]
- self.assertEquals(ou_cur["isDeleted"][0], b"TRUE")
+ self.assertEqual(ou_cur["isDeleted"][0], b"TRUE")
self.assertTrue(not(b"objectCategory" in ou_cur))
self.assertTrue(dodn in str(ou_cur["dn"]),
"OU %s is deleted but it is not located under %s!" % (name_cur, dodn))
res = sam_ldb.search(base='<GUID=%s>' % guid,
controls=["show_deleted:1"],
attrs=["isDeleted", "objectCategory", "ou"])
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
ou_cur = res[0]
# Deleted Object base DN
dodn = self._deleted_objects_dn(sam_ldb)
# now check properties of the user
name_cur = ou_cur["ou"][0]
- self.assertEquals(ou_cur["isDeleted"][0], "TRUE")
+ self.assertEqual(ou_cur["isDeleted"][0], "TRUE")
self.assertTrue(not("objectCategory" in ou_cur))
self.assertTrue(dodn in str(ou_cur["dn"]),
"OU %s is deleted but it is not located under %s!" % (name_cur, dodn))
(result, out, err) = self.runsubcmd("fsmo", "seize", "--role", "rid", "-H", ldb_url, "-s", smbconf, "--force")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
# 3. Assert we get the RID Set
res = new_ldb.search(base=server_ref_dn,
scope=ldb.SCOPE_BASE, attrs=['rIDNextRid',
'rIDAllocationPool'])
last_allocated_rid = int(rid_set_res[0]["rIDNextRid"][0])
- self.assertEquals(last_allocated_rid, last_rid - 10)
+ self.assertEqual(last_allocated_rid, last_rid - 10)
# 9. Assert that the range wasn't thrown away
# 4. Seize the RID Manager role
(result, out, err) = self.runsubcmd("fsmo", "seize", "--role", "rid", "-H", ldb_url, "-s", smbconf, "--force")
self.assertCmdSuccess(result, out, err)
- self.assertEquals(err, "", "Shouldn't be any error messages")
+ self.assertEqual(err, "", "Shouldn't be any error messages")
# 5. Add a new user (triggers RID set work)
new_ldb.newuser("ridalloctestuser", "P@ssword!")
# Show that Has-Master-NCs is fixed by samba_upgradedns
res = samdb.search(base=server_ds_name,
expression="(msds-hasmasterncs=%s)" % forestdns_dn)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
res = samdb.search(base=server_ds_name,
expression="(msds-hasmasterncs=%s)" % domaindns_dn)
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
self.check_output("samba_upgradedns -s %s" % (new_dc_config_file))
res = samdb.search(base=server_ds_name,
expression="(msds-hasmasterncs=%s)" % forestdns_dn)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
res = samdb.search(base=server_ds_name,
expression="(msds-hasmasterncs=%s)" % domaindns_dn)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
# Show that replica locations is fixed by dbcheck
res = samdb.search(controls=["search_options:1:2"],
expression="(&(msds-nc-replica-locations=%s)(ncname=%s))"
% (server_ds_name, forestdns_dn))
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
res = samdb.search(controls=["search_options:1:2"],
expression="(&(msds-nc-replica-locations=%s)(ncname=%s))"
% (server_ds_name, domaindns_dn))
- self.assertEquals(len(res), 0)
+ self.assertEqual(len(res), 0)
try:
# This fixes any forward-link-backward-link issues with the tools
# Check all ForestDNS connections and backlinks
res = samdb.search(base=server_ds_name,
expression="(msds-hasmasterncs=%s)" % forestdns_dn)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
res = samdb.search(base=forestdns_dn,
expression="(msds-masteredby=%s)" % server_ds_name)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
res = samdb.search(controls=["search_options:1:2"],
expression="(&(msds-nc-replica-locations=%s)(ncname=%s))"
% (server_ds_name, forestdns_dn))
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
# Check all DomainDNS connections and backlinks
res = samdb.search(base=server_ds_name,
expression="(msds-hasmasterncs=%s)" % domaindns_dn)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
res = samdb.search(base=domaindns_dn,
expression="(msds-masteredby=%s)" % server_ds_name)
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
res = samdb.search(controls=["search_options:1:2"],
expression="(&(msds-nc-replica-locations=%s)(ncname=%s))"
% (server_ds_name, domaindns_dn))
- self.assertEquals(len(res), 1)
+ self.assertEqual(len(res), 1)
# Demote the DC we created in the test
self.check_output("samba-tool domain demote --remove-other-dead-server=%s -H ldap://%s %s -s %s"
git.samba.org / samba.git / commitdiff