def test_check_groups_membership(self):
        if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
            self.delete_at_teardown.append(
                add_user(self.connection, testcase_id, 'user-1'))
            self.delete_at_teardown.append(
                add_group(self.connection, testcase_id, 'group-1'))
            self.delete_at_teardown.append(
                add_group(self.connection, testcase_id, 'group-2'))
            self.delete_at_teardown.append(
                add_group(self.connection, testcase_id, 'group-3'))
            self.delete_at_teardown.append(
                add_user(self.connection, testcase_id, 'user-2'))
            self.connection.extend.novell.add_members_to_groups(
                self.delete_at_teardown[0][0],
                (self.delete_at_teardown[1][0], self.delete_at_teardown[2][0]),
                fix=True,
                transaction=True)

            # valid user in valid groups
            result = self.connection.extend.novell.check_groups_memberships(
                self.delete_at_teardown[0][0],
                (self.delete_at_teardown[1][0], self.delete_at_teardown[2][0]))
            self.assertTrue(result)

            # invalid user in valid groups
            result = self.connection.extend.novell.check_groups_memberships(
                self.delete_at_teardown[4][0],
                (self.delete_at_teardown[1][0], self.delete_at_teardown[2][0]))
            self.assertFalse(result)

            # invalid user in invalid groups
            result = self.connection.extend.novell.check_groups_memberships(
                self.delete_at_teardown[0][0],
                (self.delete_at_teardown[1][0], self.delete_at_teardown[3][0]))
            self.assertFalse(result)
Пример #2
0
    def test_check_groups_memberships(self):
        if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-1'))
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-2'))
            self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-1'))
            self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-2'))
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-3'))
            self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-3'))
            self.connection.extend.novell.add_members_to_groups((self.delete_at_teardown[0][0], self.delete_at_teardown[1][0]),
                                                                self.delete_at_teardown[2][0],
                                                                fix=True,
                                                                transaction=True)

            self.connection.extend.novell.add_members_to_groups((self.delete_at_teardown[0][0], self.delete_at_teardown[1][0]),
                                                                self.delete_at_teardown[3][0],
                                                                fix=True,
                                                                transaction=True)

            # valid users in valid groups
            result = self.connection.extend.novell.check_groups_memberships((self.delete_at_teardown[0][0], self.delete_at_teardown[1][0]), (self.delete_at_teardown[2][0],self.delete_at_teardown[3][0]))
            self.assertTrue(result)

            # invalid users in valid groups
            result = self.connection.extend.novell.check_groups_memberships((self.delete_at_teardown[0][0], self.delete_at_teardown[3][0]), (self.delete_at_teardown[2][0],self.delete_at_teardown[3][0]))
            self.assertFalse(result)

            # invalid users in invalid groups
            result = self.connection.extend.novell.check_groups_memberships((self.delete_at_teardown[0][0], self.delete_at_teardown[4][0]), (self.delete_at_teardown[2][0], self.delete_at_teardown[5][0]))
            self.assertFalse(result)
Пример #3
0
    def test_add_member_to_group(self):
        if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-1'))
            self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-1'))
            self.connection.extend.novell.add_members_to_groups(self.delete_at_teardown[0][0],
                                                                self.delete_at_teardown[1][0],
                                                                check=False,
                                                                transaction=False)
            result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership'])
            if not self.connection.strategy.sync:
                response, result = self.connection.get_response(result)
            else:
                response, result = self.connection.response, self.connection.result

            if response:
                self.assertTrue(self.delete_at_teardown[1][0] in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
                self.assertTrue(self.delete_at_teardown[1][0] in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
            else:
                self.assertFalse(True, self.delete_at_teardown[1][0] + ' not found')

            result = self.connection.search(self.delete_at_teardown[1][0], '(objectclass=*)', attributes=['member', 'equivalentToMe'])
            if not self.connection.strategy.sync:
                response, result = self.connection.get_response(result)
            else:
                response, result = self.connection.response, self.connection.result

            if response:
                self.assertTrue(self.delete_at_teardown[0][0] in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
                self.assertTrue(self.delete_at_teardown[0][0] in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
            else:
                self.assertFalse(True, self.delete_at_teardown[0][0] + ' not found')
Пример #4
0
    def test_remove_member_from_group_transactional(self):
        if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-5'))
            self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-5', self.delete_at_teardown))
            self.connection.extend.novell.add_members_to_groups(self.delete_at_teardown[0][0],
                                                                self.delete_at_teardown[1][0],
                                                                check=True,
                                                                transaction=True)
            result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership'])
            if not self.connection.strategy.sync:
                response, result = self.connection.get_response(result)
            else:
                response, result = self.connection.response, self.connection.result

            if response:
                self.assertTrue(self.delete_at_teardown[1][0] in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
                self.assertTrue(self.delete_at_teardown[1][0] in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
            else:
                self.assertFalse(True, self.delete_at_teardown[1][0] + ' not found')

            result = self.connection.search(self.delete_at_teardown[1][0], '(objectclass=*)', attributes=['member', 'equivalentToMe'])
            if not self.connection.strategy.sync:
                response, result = self.connection.get_response(result)
            else:
                response, result = self.connection.response, self.connection.result

            if response:
                self.assertTrue(self.delete_at_teardown[0][0] in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
                self.assertTrue(self.delete_at_teardown[0][0] in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
            else:
                self.assertFalse(True, self.delete_at_teardown[0][0] + ' not found')

            self.connection.extend.novell.remove_members_from_groups(self.delete_at_teardown[0][0],
                                                                     self.delete_at_teardown[1][0],
                                                                     check=False,
                                                                     transaction=False)

            result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership'])
            if not self.connection.strategy.sync:
                response, result = self.connection.get_response(result)
            else:
                response, result = self.connection.response, self.connection.result

            if response:
                self.assertTrue(self.delete_at_teardown[1][0] not in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
                self.assertTrue(self.delete_at_teardown[1][0] not in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
            else:
                self.assertFalse(True, self.delete_at_teardown[1][0] + ' not found')

            result = self.connection.search(self.delete_at_teardown[1][0], '(objectclass=*)', attributes=['member', 'equivalentToMe'])
            if not self.connection.strategy.sync:
                response, result = self.connection.get_response(result)
            else:
                response, result = self.connection.response, self.connection.result

            if response:
                self.assertTrue(self.delete_at_teardown[0][0] not in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
                self.assertTrue(self.delete_at_teardown[0][0] not in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
            else:
                self.assertFalse(True, self.delete_at_teardown[0][0] + ' not found')
Пример #5
0
    def test_add_members_to_groups(self):
        if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-2'))
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-3'))
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-4'))
            self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-2', self.delete_at_teardown))
            self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-3'))
            self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-4'))
            self.connection.extend.novell.add_members_to_groups([self.delete_at_teardown[0][0],
                                                                 self.delete_at_teardown[1][0],
                                                                 self.delete_at_teardown[2][0]],
                                                                [self.delete_at_teardown[3][0],
                                                                 self.delete_at_teardown[4][0],
                                                                 self.delete_at_teardown[5][0]],
                                                                fix=True,
                                                                transaction=False
                                                                )
            for i in range(0, 2):
                result = self.connection.search(self.delete_at_teardown[i][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership'])
                if not self.connection.strategy.sync:
                    response, result = self.connection.get_response(result)
                else:
                    response, result = self.connection.response, self.connection.result

                if response:
                    for j in range(3, 5):
                        self.assertTrue(self.delete_at_teardown[j][0] in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
                        self.assertTrue(self.delete_at_teardown[j][0] in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
                else:
                    self.assertFalse(True, self.delete_at_teardown[i][0] + ' not found')

            for j in range(3, 5):
                result = self.connection.search(self.delete_at_teardown[j][0], '(objectclass=*)', attributes=['member', 'equivalentToMe'])
                if not self.connection.strategy.sync:
                    response, result = self.connection.get_response(result)
                else:
                    response, result = self.connection.response, self.connection.result

                if response:
                    for i in range(0, 2):
                        self.assertTrue(self.delete_at_teardown[i][0] in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
                        self.assertTrue(self.delete_at_teardown[i][0] in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
                else:
                    self.assertFalse(True, self.delete_at_teardown[j][0] + ' not found')
Пример #6
0
    def test_add_members_to_groups_transactional(self):
        if test_server_type == 'EDIR' and not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-6'))
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-7'))
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'user-8'))
            self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-6', self.delete_at_teardown))  # this group has members but other attributes are not set
            self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-7'))
            self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'group-8'))
            self.connection.extend.novell.add_members_to_groups([self.delete_at_teardown[0][0],
                                                                 self.delete_at_teardown[1][0],
                                                                 self.delete_at_teardown[2][0]],
                                                                [self.delete_at_teardown[3][0],
                                                                 self.delete_at_teardown[4][0],
                                                                 self.delete_at_teardown[5][0]],
                                                                check=True,
                                                                transaction=True
                                                                )
            for i in range(0, 2):
                result = self.connection.search(self.delete_at_teardown[i][0], '(objectclass=*)', attributes=['securityEquals', 'groupMembership'])
                if not self.connection.strategy.sync:
                    response, result = self.connection.get_response(result)
                else:
                    response, result = self.connection.response, self.connection.result

                if response:
                    for j in range(3, 5):
                        self.assertTrue(self.delete_at_teardown[j][0] in (response[0]['attributes']['securityEquals'] if 'securityEquals' in response[0]['attributes'] else []))
                        self.assertTrue(self.delete_at_teardown[j][0] in (response[0]['attributes']['groupMembership'] if 'groupMembership' in response[0]['attributes'] else []))
                else:
                    self.assertFalse(True, self.delete_at_teardown[i][0] + ' not found')

            for j in range(3, 5):
                result = self.connection.search(self.delete_at_teardown[j][0], '(objectclass=*)', attributes=['member', 'equivalentToMe'])
                if not self.connection.strategy.sync:
                    response, result = self.connection.get_response(result)
                else:
                    response, result = self.connection.response, self.connection.result

                if response:
                    for i in range(0, 2):
                        self.assertTrue(self.delete_at_teardown[i][0] in (response[0]['attributes']['member'] if 'member' in response[0]['attributes'] else []))
                        self.assertTrue(self.delete_at_teardown[i][0] in (response[0]['attributes']['equivalentToMe'] if 'equivalentToMe' in response[0]['attributes'] else []))
                else:
                    self.assertFalse(True, self.delete_at_teardown[j][0] + ' not found')
Пример #7
0
    def test_search_with_dereference(self):
        reverse = lambda a, e: e[::-1]

        def raise_parentheses_rank(_, l):
            up = {'(': '[', ')': ']', '[': '{', ']': '}', '{': '<', '}': '>'}
            r = []
            for e in l:
                s = ''
                for c in e:
                    s += up[c] if c in up else c
                r.append(s)

            return r

        self.delete_at_teardown.append(
            add_user(self.connection, testcase_id, 'abstract-member-4'))
        self.delete_at_teardown.append(
            add_user(self.connection, testcase_id, 'abstract-member-5'))
        self.delete_at_teardown.append(
            add_user(self.connection, testcase_id, 'abstract-member-6'))
        self.delete_at_teardown.append(
            add_group(self.connection, testcase_id, 'abstract-group',
                      self.delete_at_teardown))
        ou = ObjectDef('inetOrgPerson')
        ou += AttrDef('cn', 'Common Name', post_query=reverse)
        ou += AttrDef('sn', 'Surname')
        ou += AttrDef('givenName',
                      'Given Name',
                      post_query=raise_parentheses_rank)
        ou += AttrDef('ACL')
        qu = 'Common Name: ' + testcase_id + 'abstract-member-*'
        ru = Reader(self.connection, ou, test_base, qu)
        lu = ru.search()
        self.assertEqual(len(lu), 3)

        og = ObjectDef('groupOfNames')
        og += AttrDef('member', dereference_dn=ou)
        og += 'cn'
        qg = 'cn := ' + testcase_id + 'abstract-group'
        rg = Reader(self.connection, og, test_base, qg)
        lg = rg.search()
        self.assertEqual(len(lg), 1)

        eg = lg[0]
        mg = eg.member
        self.assertEqual(len(mg), 3)
        ug = eg.member[0]
        self.assertTrue(
            str(ug.surname) in
            ['abstract-member-4', 'abstract-member-5', 'abstract-member-6'])
Пример #8
0
    def test_search_filter_with_object_class(self):
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-1'))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-2'))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-3'))
        self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'abs-grp', self.delete_at_teardown))
        reverse = lambda a, e: e[::-1]
        o = ObjectDef('inetOrgPerson')
        o += AttrDef('cn', 'Common Name')
        o += AttrDef('sn', 'Surname')
        o += AttrDef('givenName', 'Given Name', post_query=reverse)

        query_text = 'Common Name:=' + testcase_id + 'abs-*'
        r = Reader(self.connection, o, query_text, test_base)

        results = r.search()
        self.assertEqual(len(results), 3)
Пример #9
0
    def test_search_filter_with_object_class(self):
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-1'))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-2'))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abs-3'))
        self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'abs-grp', self.delete_at_teardown))
        reverse = lambda a, e: e[::-1]
        o = ObjectDef('inetOrgPerson')
        o += AttrDef('cn', 'Common Name')
        o += AttrDef('sn', 'Surname')
        o += AttrDef('givenName', 'Given Name', post_query=reverse)

        query_text = 'Common Name:=' + testcase_id + 'abs-*'
        r = Reader(self.connection, o, query_text, test_base)

        results = r.search()
        self.assertEqual(len(results), 3)
Пример #10
0
    def test_search_filter_with_object_class(self):
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, "abs-1"))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, "abs-2"))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, "abs-3"))
        self.delete_at_teardown.append(add_group(self.connection, testcase_id, "abs-grp", self.delete_at_teardown))
        reverse = lambda a, e: e[::-1]
        o = ObjectDef("inetOrgPerson")
        o += AttrDef("cn", "Common Name")
        o += AttrDef("sn", "Surname")
        o += AttrDef("givenName", "Given Name", post_query=reverse)

        query_text = "Common Name:=" + testcase_id + "abs-*"
        r = Reader(self.connection, o, query_text, test_base)

        results = r.search()
        self.assertEqual(len(results), 3)
Пример #11
0
    def test_search_with_pre_query(self):
        change = lambda attr, value: testcase_id + 'abstract-member-*'

        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abstract-member-7'))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abstract-member-8'))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abstract-member-9'))
        self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'abstract-group', self.delete_at_teardown))

        ou = ObjectDef('inetOrgPerson')
        ou += AttrDef('cn', 'Common Name', pre_query=change)
        ou += AttrDef('sn', 'Surname')
        ou += AttrDef('givenName', 'Given Name')
        ou += AttrDef('ACL')
        qu = 'Common Name := bug'
        ru = Reader(self.connection, ou, qu, test_base)
        lu = ru.search()
        self.assertEqual(len(lu), 3)
Пример #12
0
    def test_search_with_pre_query(self):
        change = lambda attr, value: testcase_id + 'abstract-member-*'

        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abstract-member-7'))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abstract-member-8'))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abstract-member-9'))
        self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'abstract-group', self.delete_at_teardown))

        ou = ObjectDef('inetOrgPerson')
        ou += AttrDef('cn', 'Common Name', pre_query=change)
        ou += AttrDef('sn', 'Surname')
        ou += AttrDef('givenName', 'Given Name')
        ou += AttrDef('ACL')
        qu = 'Common Name := bug'
        ru = Reader(self.connection, ou, qu, test_base)
        lu = ru.search()
        self.assertEqual(len(lu), 3)
Пример #13
0
    def test_search_with_dereference(self):
        reverse = lambda a, e: e[::-1]

        def raise_parentheses_rank(_, l):
            up = {"(": "[", ")": "]", "[": "{", "]": "}", "{": "<", "}": ">"}
            r = []
            for e in l:
                s = ""
                for c in e:
                    s += up[c] if c in up else c
                r.append(s)

            return r

        self.delete_at_teardown.append(add_user(self.connection, testcase_id, "abstract-member-4"))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, "abstract-member-5"))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, "abstract-member-6"))
        self.delete_at_teardown.append(
            add_group(self.connection, testcase_id, "abstract-group", self.delete_at_teardown)
        )
        ou = ObjectDef("inetOrgPerson")
        ou += AttrDef("cn", "Common Name", post_query=reverse)
        ou += AttrDef("sn", "Surname")
        ou += AttrDef("givenName", "Given Name", post_query=raise_parentheses_rank)
        ou += AttrDef("ACL")
        qu = "Common Name: " + testcase_id + "abstract-member-*"
        ru = Reader(self.connection, ou, qu, test_base)
        lu = ru.search()
        self.assertEqual(len(lu), 3)

        og = ObjectDef("groupOfNames")
        og += AttrDef("member", dereference_dn=ou)
        og += "cn"
        qg = "cn := " + testcase_id + "abstract-group"
        rg = Reader(self.connection, og, qg, test_base)
        lg = rg.search()
        self.assertEqual(len(lg), 1)

        eg = lg[0]
        mg = eg.member
        self.assertEqual(len(mg), 3)
        ug = eg.member[0]
        self.assertTrue(str(ug.surname) in ["abstract-member-4", "abstract-member-5", "abstract-member-6"])
Пример #14
0
    def test_search_with_pre_query(self):
        change = lambda attr, value: testcase_id + "abstract-member-*"

        self.delete_at_teardown.append(add_user(self.connection, testcase_id, "abstract-member-7"))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, "abstract-member-8"))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, "abstract-member-9"))
        self.delete_at_teardown.append(
            add_group(self.connection, testcase_id, "abstract-group", self.delete_at_teardown)
        )

        ou = ObjectDef("inetOrgPerson")
        ou += AttrDef("cn", "Common Name", pre_query=change)
        ou += AttrDef("sn", "Surname")
        ou += AttrDef("givenName", "Given Name")
        ou += AttrDef("ACL")
        qu = "Common Name := bug"
        ru = Reader(self.connection, ou, qu, test_base)
        lu = ru.search()
        self.assertEqual(len(lu), 3)
Пример #15
0
    def test_search_with_dereference(self):
        reverse = lambda a, e: e[::-1]

        def raise_parentheses_rank(_, l):
            up = {'(': '[', ')': ']', '[': '{', ']': '}', '{': '<', '}': '>'}
            r = []
            for e in l:
                s = ''
                for c in e:
                    s += up[c] if c in up else c
                r.append(s)

            return r

        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abstract-member-4'))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abstract-member-5'))
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abstract-member-6'))
        self.delete_at_teardown.append(add_group(self.connection, testcase_id, 'abstract-group', self.delete_at_teardown))
        ou = ObjectDef('inetOrgPerson')
        ou += AttrDef('cn', 'Common Name', post_query=reverse)
        ou += AttrDef('sn', 'Surname')
        ou += AttrDef('givenName', 'Given Name', post_query=raise_parentheses_rank)
        ou += AttrDef('ACL')
        qu = 'Common Name: ' + testcase_id + 'abstract-member-*'
        ru = Reader(self.connection, ou, qu, test_base)
        lu = ru.search()
        self.assertEqual(len(lu), 3)

        og = ObjectDef('groupOfNames')
        og += AttrDef('member', dereference_dn=ou)
        og += 'cn'
        qg = 'cn := ' + testcase_id + 'abstract-group'
        rg = Reader(self.connection, og, qg, test_base)
        lg = rg.search()
        self.assertEqual(len(lg), 1)

        eg = lg[0]
        mg = eg.member
        self.assertEqual(len(mg), 3)
        ug = eg.member[0]
        self.assertTrue(str(ug.surname) in ['abstract-member-4', 'abstract-member-5', 'abstract-member-6'])