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)
Example #2
0
 def setUp(self):
     self.connection = get_connection()
     self.delete_at_teardown = []
     self.delete_at_teardown.append(
         add_user(self.connection, testcase_id, 'ldif-content-1'))
     self.delete_at_teardown.append(
         add_user(self.connection, testcase_id, 'ldif-content-2'))
    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)
Example #4
0
    def test_find_entry_with_text_index_match(self):
        self.delete_at_teardown.append(
            add_user(self.connection, testcase_id, 'match-1'))
        self.delete_at_teardown.append(
            add_user(self.connection, testcase_id, 'match-2'))
        self.delete_at_teardown.append(
            add_user(self.connection, testcase_id, 'match-3'))
        o = ObjectDef('inetOrgPerson')
        o += AttrDef('cn', 'Common Name')
        o += AttrDef('sn', 'Surname')
        o += AttrDef('givenName', 'Given Name')

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

        results = r.search()
        self.assertEqual(len(results), 3)
        try:  # multiple matches
            e = r['match']
        except KeyError:
            pass

        e = r['-2']  # exact match
        self.assertTrue(e.entry_dn.endswith('match-2,ou=fixtures,o=test'))

        try:
            e = r['no-match']  # no match
        except KeyError:
            pass
 def setUp(self):
     self.connection = get_connection(check_names=True, get_info=ALL)
     self.delete_at_teardown = []
     if test_server_type == 'EDIR':
         self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'checked-attributes-1', attributes={'loginGraceLimit': 0}))
     elif test_server_type == 'AD':
         self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'checked-attributes-1'))
     else:
         self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'checked-attributes-1'))
 def setUp(self):
     self.connection = get_connection(check_names=True, get_info=ALL)
     self.delete_at_teardown = []
     if test_server_type == 'EDIR':
         self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'checked-attributes-1', attributes={'loginGraceLimit': 0}))
     elif test_server_type == 'AD':
         self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'checked-attributes-1'))
     else:
         self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'checked-attributes-1'))
Example #7
0
 def setUp(self):
     self.connection = get_connection(use_ssl=True)
     self.delete_at_teardown = []
     if test_server_type == "AD":
         self.delete_at_teardown.append(
             add_user(self.connection, testcase_id, "search-1", attributes={"givenName": "givenname-1"})
         )
         self.delete_at_teardown.append(
             add_user(self.connection, testcase_id, "search-2", attributes={"givenName": "givenname-2"})
         )
Example #8
0
 def setUp(self):
     if test_server_type == 'AD':
         self.connection = get_connection(use_ssl=True)
         self.delete_at_teardown = []
         self.delete_at_teardown.append(
             add_user(self.connection,
                      testcase_id,
                      'search-1',
                      attributes={'givenName': 'givenname-1'}))
         self.delete_at_teardown.append(
             add_user(self.connection,
                      testcase_id,
                      'search-2',
                      attributes={'givenName': 'givenname-2'}))
Example #9
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'])
Example #10
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')
Example #11
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)
Example #12
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)
Example #13
0
    def test_search_deleted_objects_ad(self):
        if test_server_type == "AD":
            dn_to_delete, _ = add_user(
                self.connection, testcase_id, "to-be-deleted-1", attributes={"givenName": "to-be-deleted-1"}
            )
            sleep(1)
            self.connection.delete(dn_to_delete)
            sleep(1)
            result = self.connection.search(
                search_base=test_root_partition,
                search_filter="(&(isDeleted=TRUE)(cn=*" + testcase_id + "*deleted-1*))",
                search_scope=SUBTREE,
                attributes=[],
                controls=[show_deleted_control(criticality=True)],
            )
            if not self.connection.strategy.sync:
                response, result = self.connection.get_response(result)
            else:
                response = self.connection.response
                result = self.connection.result
            found = False
            for entry in response:
                if entry["type"] == "searchResEntry" and testcase_id in entry["dn"]:
                    found = True
                    break

            self.assertTrue(found)
Example #14
0
    def test_modify_password_as_administrator(self):
        if test_server_type == "AD":
            self.delete_at_teardown.append(
                add_user(
                    self.connection, testcase_id, "changed-password-1", attributes={"givenName": "changed-password-1"}
                )
            )
            dn = self.delete_at_teardown[-1][0]
            # test_connection = get_connection(bind=False, authentication=SIMPLE, simple_credentials=(dn, 'Rc1234abcd'))
            # test_connection.bind()
            # self.assertTrue(test_connection.bound)
            # connected_user = test_connection.extend.standard.who_am_i()
            # test_connection.unbind()
            # self.assertTrue('changed-password-1' in connected_user)

            new_password = "******"
            result = self.connection.extend.microsoft.modify_password(dn, new_password)
            self.assertEqual(result, True)
            # creates a second connection and tries to bind with the new password
            test_connection = get_connection(bind=False, authentication=SIMPLE, simple_credentials=(dn, new_password))
            test_connection.bind()
            connected_user = test_connection.extend.standard.who_am_i()
            test_connection.unbind()

            self.assertTrue("changed-password-1" in connected_user)
Example #15
0
    def test_search_exact_match_with_parentheses_in_filter(self):
        self.delete_at_teardown.append(
            add_user(self.connection,
                     testcase_id,
                     '(search)-3',
                     attributes={'givenName': 'givenname-3'}))
        result = self.connection.search(
            search_base=test_base,
            search_filter='(&(' + test_name_attr + '=' + testcase_id + '*)(' +
            test_name_attr + '=*' + escape_bytes(')') + '*))',
            attributes=[test_name_attr, 'sn'])
        if not self.connection.strategy.sync:
            response, _ = self.connection.get_response(result)
            json_response = self.connection.response_to_json(
                search_result=response)
        else:
            json_response = self.connection.response_to_json()
        json_entries = json.loads(json_response)['entries']

        self.assertEqual(len(json_entries), 1)
        if test_server_type == 'AD':
            self.assertEqual(json_entries[0]['attributes'][test_name_attr],
                             testcase_id + '(search)-3')
        else:
            self.assertEqual(json_entries[0]['attributes'][test_name_attr][0],
                             testcase_id + '(search)-3')
Example #16
0
    def test_modify_password_as_administrator(self):
        if test_server_type == 'AD':
            self.delete_at_teardown.append(
                add_user(self.connection,
                         testcase_id,
                         'changed-password-1',
                         attributes={'givenName': 'changed-password-1'}))
            dn = self.delete_at_teardown[-1][0]
            # test_connection = get_connection(bind=False, authentication=SIMPLE, simple_credentials=(dn, 'Rc1234abcd'))
            # test_connection.bind()
            # self.assertTrue(test_connection.bound)
            # connected_user = test_connection.extend.standard.who_am_i()
            # test_connection.unbind()
            # self.assertTrue('changed-password-1' in connected_user)

            new_password = '******'
            result = self.connection.extend.microsoft.modify_password(
                dn, new_password)
            self.assertEqual(result, True)
            # creates a second connection and tries to bind with the new password
            test_connection = get_connection(bind=False,
                                             authentication=SIMPLE,
                                             simple_credentials=(dn,
                                                                 new_password))
            test_connection.bind()
            connected_user = test_connection.extend.standard.who_am_i()
            test_connection.unbind()

            self.assertTrue('changed-password-1' in connected_user)
Example #17
0
    def test_search_deleted_objects_ad(self):
        if test_server_type == 'AD':
            dn_to_delete, _ = add_user(
                self.connection,
                testcase_id,
                'to-be-deleted-1',
                attributes={'givenName': 'to-be-deleted-1'})
            sleep(1)
            self.connection.delete(dn_to_delete)
            sleep(1)
            result = self.connection.search(
                search_base=test_root_partition,
                search_filter='(&(isDeleted=TRUE)(cn=*' + testcase_id +
                '*deleted-1*))',
                search_scope=SUBTREE,
                attributes=[],
                controls=[show_deleted_control(criticality=True)])
            if not self.connection.strategy.sync:
                response, result = self.connection.get_response(result)
            else:
                response = self.connection.response
                result = self.connection.result
            found = False
            for entry in response:
                if entry['type'] == 'searchResEntry' and testcase_id in entry[
                        'dn']:
                    found = True
                    break

            self.assertTrue(found)
Example #18
0
    def test_modify_password_as_normal_user(self):
        if test_server_type == 'AD':
            old_password = '******'
            new_password = '******'
            self.delete_at_teardown.append(
                add_user(self.connection,
                         testcase_id,
                         'changed-password-2',
                         password=old_password,
                         attributes={'givenName': 'changed-password-2'}))
            dn = self.delete_at_teardown[-1][0]
            # creates a second connection and tries to bind with the new password
            test_connection = get_connection(bind=False,
                                             authentication=SIMPLE,
                                             simple_credentials=(dn,
                                                                 old_password))
            test_connection.bind()
            self.assertTrue(test_connection.bound)
            connected_user = test_connection.extend.standard.who_am_i()
            test_connection.unbind()
            self.assertTrue('changed-password-2' in connected_user)

            # changee the password
            result = self.connection.extend.microsoft.modify_password(
                dn, new_password, old_password)
            self.assertEqual(result, True)

            # tries to bind with the new password
            test_connection.password = new_password
            test_connection.bind()
            connected_user = test_connection.extend.standard.who_am_i()
            test_connection.unbind()

            self.assertTrue('changed-password-2' in connected_user)
    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')
Example #20
0
    def test_modify_password_as_normal_user(self):
        if test_server_type == 'AD':
            old_password = '******'
            new_password = '******'
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'changed-password-2', password=old_password, attributes={'givenName': 'changed-password-2'}))
            dn = self.delete_at_teardown[-1][0]
            # creates a second connection and tries to bind with the new password
            test_connection = get_connection(bind=False, authentication=SIMPLE, simple_credentials=(dn, old_password))
            test_connection.bind()
            self.assertTrue(test_connection.bound)
            connected_user = test_connection.extend.standard.who_am_i()
            test_connection.unbind()
            self.assertTrue('changed-password-2' in connected_user)

            # changee the password
            result = self.connection.extend.microsoft.modify_password(dn, new_password, old_password)
            self.assertEqual(result, True)

            # tries to bind with the new password
            test_connection.password =  new_password
            test_connection.bind()
            connected_user = test_connection.extend.standard.who_am_i()
            test_connection.unbind()

            self.assertTrue('changed-password-2' in connected_user)
    def test_abort_transaction(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'))
            transaction_control = self.connection.extend.novell.start_transaction(
            )
            self.connection.modify(
                self.delete_at_teardown[0][0],
                {'givenName': (MODIFY_REPLACE, ['user-1b'])},
                controls=[transaction_control])
            self.connection.modify(self.delete_at_teardown[0][0],
                                   {'sn': (MODIFY_REPLACE, ['sn-user-1b'])},
                                   controls=[transaction_control])
            result = self.connection.extend.novell.end_transaction(
                commit=False, controls=[transaction_control])
            result = self.connection.search(self.delete_at_teardown[0][0],
                                            '(objectclass=*)',
                                            attributes=['givenName', 'sn'])
            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.assertEquals(response[0]['attributes']['givenName'][0], 'user-1b')
                self.assertEquals(response[0]['attributes']['sn'][0], 'user-1')
            else:
                self.assertFalse(True,
                                 self.delete_at_teardown[0][0] + ' not found')
Example #22
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)
    def test_invalid_transaction_cookie(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'))
            transaction_control = self.connection.extend.novell.start_transaction(
            )
            invalid_transaction_control = build_control(
                '2.16.840.1.113719.1.27.103.7',
                True,
                Integer(12345678),
                encode_control_value=True)
            self.connection.modify(
                self.delete_at_teardown[0][0],
                {'givenName': (MODIFY_REPLACE, ['user-1b'])},
                controls=[transaction_control])
            self.connection.modify(self.delete_at_teardown[0][0],
                                   {'sn': (MODIFY_REPLACE, ['sn-user-1b'])},
                                   controls=[invalid_transaction_control])
            result = self.connection.extend.novell.end_transaction(
                commit=True, controls=[transaction_control])
            result = self.connection.search(self.delete_at_teardown[0][0],
                                            '(objectclass=*)',
                                            attributes=['givenName', 'sn'])
            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.assertEquals(response[0]['attributes']['givenName'][0],
                                  'user-1b')
                self.assertEquals(response[0]['attributes']['sn'][0], 'user-1')
            else:
                self.assertFalse(True,
                                 self.delete_at_teardown[0][0] + ' not found')
Example #24
0
 def setUp(self):
     self.connection = get_connection()
     self.delete_at_teardown = []
     self.delete_at_teardown.append(
         add_user(self.connection,
                  testcase_id,
                  'modify-1',
                  attributes={'givenName': 'givenname-1'}))
Example #25
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)
Example #26
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)
Example #27
0
 def setUp(self):
     self.connection = get_connection(check_names=True)
     self.delete_at_teardown = []
     self.delete_at_teardown.append(
         add_user(self.connection,
                  testcase_id,
                  'compare-1',
                  attributes={'givenName': 'compare'}))
Example #28
0
 def test_valid_object_class_add(self):
     self.delete_at_teardown.append(
         add_user(self.connection,
                  testcase_id,
                  'check-names-3',
                  attributes={'objectClass': ['inetOrgPerson', 'Person']}))
     self.assertEqual(self.delete_at_teardown[0][1]['description'],
                      'success')
    def test_search_simple_paged(self):
        if not self.connection.strategy.pooled and not self.connection.strategy.no_real_dsa:
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-3', attributes={'givenName': 'givenname-3'}))
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-4', attributes={'givenName': 'givenname-4'}))
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-5', attributes={'givenName': 'givenname-5'}))
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-6', attributes={'givenName': 'givenname-6'}))
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-7', attributes={'givenName': 'givenname-7'}))
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-8', attributes={'givenName': 'givenname-8'}))
            self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-9', attributes={'givenName': 'givenname-9'}))

            paged_size = 4
            total_entries = 0
            result = self.connection.search(search_base=test_base, search_filter='(' + test_name_attr + '=' + testcase_id + '*)', search_scope=SUBTREE, attributes=[test_name_attr, 'givenName'], paged_size=paged_size)
            if not self.connection.strategy.sync:
                response, result = self.connection.get_response(result)
            else:
                response = self.connection.response
                result = self.connection.result
            self.assertEqual(result['description'], 'success')
            self.assertEqual(len(response), paged_size)
            total_entries += len(response)
            cookie = result['controls']['1.2.840.113556.1.4.319']['value']['cookie']
            while cookie:
                result = self.connection.search(search_base=test_base, search_filter='(' + test_name_attr + '=' + testcase_id + '*)', search_scope=SUBTREE, attributes=[test_name_attr, 'givenName'], paged_size=paged_size, paged_cookie=cookie)
                if not self.connection.strategy.sync:
                    response, result = self.connection.get_response(result)
                else:
                    response = self.connection.response
                    result = self.connection.result
                self.assertEqual(result['description'], 'success')
                total_entries += len(response)
                self.assertTrue(len(response) <= paged_size)
                cookie = result['controls']['1.2.840.113556.1.4.319']['value']['cookie']
            self.assertEqual(total_entries, 9)
Example #30
0
    def test_add_bytes(self):
        self.delete_at_teardown.append(
            add_user(self.connection,
                     testcase_id,
                     'add-operation-1',
                     test_bytes=True))

        self.assertEqual('success',
                         self.delete_at_teardown[0][1]['description'])
Example #31
0
 def test_modify_dn_operation(self):
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'modify-dn-1'))
     result = self.connection.modify_dn(self.delete_at_teardown[0][0], test_name_attr + '=' + testcase_id + 'modified-dn-1')
     if not self.connection.strategy.sync:
         _, result = self.connection.get_response(result)
     else:
         result = self.connection.result
     self.assertEqual(result['description'], 'success')
     self.delete_at_teardown[0] = (self.delete_at_teardown[0][0].replace('modify-dn-1', 'modified-dn-1'), self.delete_at_teardown[0][1])
 def test_search_object(self):
     self.delete_at_teardown.append(
         add_user(self.connection, testcase_id, 'abstract-1'))
     o = ObjectDef(['inetorgPerson', 'person'], self.connection)
     r = Reader(self.connection, o, test_base,
                '(cn=' + testcase_id + 'abstract-1)')
     r.search()
     self.assertEqual(len(r), 1)
     self.assertEqual(r.entries[0].cn, testcase_id + 'abstract-1')
Example #33
0
 def test_modify_dn_operation(self):
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'modify-dn-1'))
     result = self.connection.modify_dn(self.delete_at_teardown[0][0], test_name_attr + '=' + testcase_id + 'modified-dn-1')
     if not self.connection.strategy.sync:
         _, result = self.connection.get_response(result)
     else:
         result = self.connection.result
     self.assertEqual(result['description'], 'success')
     self.delete_at_teardown[0] = (self.delete_at_teardown[0][0].replace('modify-dn-1', 'modified-dn-1'), self.delete_at_teardown[0][1])
 def setUp(self):
     self.connection = get_connection(check_names=True)
     self.delete_at_teardown = []
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, "paged_search-1"))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, "paged_search-2"))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, "paged_search-3"))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, "paged_search-4"))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, "paged_search-5"))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, "paged_search-6"))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, "paged_search-7"))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, "paged_search-8"))
Example #35
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')
 def setUp(self):
     self.connection = get_connection(check_names=True)
     self.delete_at_teardown = []
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'paged_search-1'))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'paged_search-2'))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'paged_search-3'))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'paged_search-4'))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'paged_search-5'))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'paged_search-6'))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'paged_search-7'))
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'paged_search-8'))
Example #37
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')
Example #38
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)
Example #39
0
    def test_search_with_None_default(self):
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abstract-member-12'))

        ou = ObjectDef('inetOrgPerson')
        ou += AttrDef('cn', 'CommonName')
        ou += AttrDef('employeeType', key='Employee', default=None)
        qu = 'CommonName := ' + testcase_id + 'abstract-member-12'
        ru = Reader(self.connection, ou, qu, test_base)
        lu = ru.search()
        self.assertEqual(lu[0].employee.value, None)
Example #40
0
    def test_match_in_single_attribute_with_schema(self):
        self.delete_at_teardown.append(
            add_user(self.connection,
                     testcase_id,
                     'match-1',
                     attributes={
                         'givenname': ['givenname-1', 'givenname-1a'],
                         'loginDisabled': 'FALSE'
                     }))
        self.delete_at_teardown.append(
            add_user(self.connection,
                     testcase_id,
                     'match-2',
                     attributes={
                         'givenname': ['givenname-2', 'givenname-2a'],
                         'loginDisabled': 'FALSE'
                     }))
        self.delete_at_teardown.append(
            add_user(self.connection,
                     testcase_id,
                     'match-3',
                     attributes={
                         'givenname': ['givenname-3', 'givenname-3a'],
                         'loginDisabled': 'TRUE'
                     }))
        r = Reader(self.connection, 'inetorgperson', test_base,
                   'cn:=' + testcase_id + 'match-*')

        results = r.search()
        self.assertEqual(len(results), 3)

        e = r.match('givenname', 'name')  # multiple matches
        self.assertEqual(len(e), 3)
        e = r.match('givenname', '2a')  # single match
        self.assertEqual(len(e), 1)
        e = r.match('givenname', 'no-match')  # no match
        self.assertEqual(len(e), 0)
        e = r.match('loginDisabled', False)
        self.assertEqual(len(e), 2)
        e = r.match('loginDisabled', 'FALSE')
        self.assertEqual(len(e), 2)
        e = r.match('loginDisabled', 'fAlSe')
        self.assertEqual(len(e), 2)
Example #41
0
    def test_match_in_multiple_attribute(self):
        self.delete_at_teardown.append(
            add_user(self.connection,
                     testcase_id,
                     'match-1',
                     attributes={
                         'givenname': ['givenname-1', 'givenname-1a'],
                         'street': '1a'
                     }))
        self.delete_at_teardown.append(
            add_user(self.connection,
                     testcase_id,
                     'match-2',
                     attributes={
                         'givenname': ['givenname-2', 'givenname-2a'],
                         'street': '3a'
                     }))
        self.delete_at_teardown.append(
            add_user(self.connection,
                     testcase_id,
                     'match-3',
                     attributes={
                         'givenname': ['givenname-3', 'givenname-3a'],
                         'street': '4a'
                     }))
        o = ObjectDef('inetOrgPerson')
        o += AttrDef('cn', 'Common Name')
        o += AttrDef('sn', 'Surname')
        o += AttrDef('givenName', 'Given Name')
        o += AttrDef('street', 'Street')

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

        results = r.search()
        self.assertEqual(len(results), 3)

        e = r.match(['givenname', 'street'], '3a')  # multiple matches
        self.assertEqual(len(e), 2)
        e = r.match(['givenname', 'street'], '1a')  # single match
        self.assertEqual(len(e), 1)
        e = r.match(['givenname', 'street'], 'no-match')  # no match
        self.assertEqual(len(e), 0)
Example #42
0
    def test_search_with_None_default(self):
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'abstract-member-12'))

        ou = ObjectDef('inetOrgPerson')
        ou += AttrDef('cn', 'CommonName')
        ou += AttrDef('employeeType', key='Employee', default=None)
        qu = 'CommonName := ' + testcase_id + 'abstract-member-12'
        ru = Reader(self.connection, ou, qu, test_base)
        lu = ru.search()
        self.assertEqual(lu[0].employee.value, None)
Example #43
0
    def test_search_with_None_default(self):
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, "abstract-member-12"))

        ou = ObjectDef("inetOrgPerson")
        ou += AttrDef("cn", "CommonName")
        ou += AttrDef("employeeType", key="Employee", default=None)
        qu = "CommonName := " + testcase_id + "abstract-member-12"
        ru = Reader(self.connection, ou, qu, test_base)
        lu = ru.search()
        self.assertEqual(lu[0].employee.value, None)
Example #44
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"])
Example #45
0
 def test_valid_attribute(self):
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'check-names-2', attributes={'givenName': 'given-name-2'}))
     result = self.connection.search(search_base=test_base, search_filter='(' + test_name_attr + '=' + testcase_id + 'check-names-2)', attributes=[test_name_attr, 'givenName'])
     if not self.connection.strategy.sync:
         response, result = self.connection.get_response(result)
     else:
         response = self.connection.response
         result = self.connection.result
     self.assertEqual(result['description'], 'success')
     self.assertEqual(len(response), 1)
 def test_search_exact_match_with_parentheses_in_filter(self):
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, '(search)-10', attributes={'givenName': 'givenname-10'}))
     result = self.connection.search(search_base=test_base, search_filter='(' + test_name_attr + '=' + testcase_id + '*' + escape_bytes(')') + '*)', attributes=[test_name_attr, 'sn'])
     if not self.connection.strategy.sync:
         response, result = self.connection.get_response(result)
     else:
         response = self.connection.response
         result = self.connection.result
     self.assertEqual(result['description'], 'success')
     self.assertEqual(len(response), 1)
     self.assertEqual(response[0]['attributes'][test_name_attr][0], testcase_id + '(search)-10')
Example #47
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'])
 def test_search_exact_match_with_parentheses_in_filter(self):
     self.delete_at_teardown.append(add_user(self.connection, testcase_id, '(search)-10', attributes={'givenName': 'givenname-10'}))
     result = self.connection.search(search_base=test_base, search_filter='(' + test_name_attr + '=' + testcase_id + '*' + escape_bytes(')') + '*)', attributes=[test_name_attr, 'sn'])
     if not self.connection.strategy.sync:
         response, result = self.connection.get_response(result)
         entries = self.connection._get_entries(response)
     else:
         result = self.connection.result
         entries = self.connection.entries
     self.assertEqual(result['description'], 'success')
     self.assertEqual(len(entries), 1)
     self.assertEqual(entries[0][test_name_attr][0], testcase_id + '(search)-10')
Example #49
0
    def test_search_exact_match_with_parentheses_in_filter(self):
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, '(search)-3', attributes={'givenName': 'givenname-3'}))
        result = self.connection.search(search_base=test_base, search_filter='(&(' + test_name_attr + '=' + testcase_id + '*)(' + test_name_attr + '=*' + escape_bytes(')') + '*))', attributes=[test_name_attr, 'sn'])
        if not self.connection.strategy.sync:
            response, _ = self.connection.get_response(result)
            json_response = self.connection.response_to_json(search_result=response)
        else:
            json_response = self.connection.response_to_json()
        json_entries = json.loads(json_response)['entries']

        self.assertEqual(len(json_entries), 1)
        self.assertEqual(json_entries[0]['attributes'][test_name_attr][0], testcase_id + '(search)-3')
Example #50
0
    def test_search_and_delete_entry(self):
        add_user(self.connection,
                 testcase_id,
                 'search-and-delete',
                 attributes={
                     'givenName': 'givenname-delete',
                     test_int_attr: 0
                 })
        read_only_entry = self.get_entry('search-and-delete')
        self.assertEqual(read_only_entry.entry_status, STATUS_READ)
        writable_entry = read_only_entry.entry_writable('inetorgperson')
        self.assertEqual(writable_entry.entry_status, STATUS_WRITABLE)
        writable_entry.entry_delete()
        self.assertEqual(writable_entry.entry_status,
                         STATUS_READY_FOR_DELETION)
        result = writable_entry.entry_commit_changes()
        self.assertEqual(writable_entry.entry_status, STATUS_DELETED)
        self.assertTrue(result)
        counter = 20
        while counter > 0:  # waits for at maximum 20 times - delete operation can take some time to complete
            result = self.connection.search(
                search_base=test_base,
                search_filter='(' + test_name_attr + '=' + testcase_id +
                'search-and-delete)',
                attributes=[test_name_attr, 'givenName'])
            if not self.connection.strategy.sync:
                response, result = self.connection.get_response(result)
                entries = self.connection._get_entries(response)
            else:
                result = self.connection.result
                entries = self.connection.entries
            if len(entries) == 0:
                break
            sleep(3)
            counter -= 1

        self.assertEqual(result['description'], 'success')
        self.assertEqual(len(entries), 0)
        self.compare_entries(read_only_entry, writable_entry)
Example #51
0
    def test_match_dn_in_cursor(self):
        self.delete_at_teardown.append(
            add_user(self.connection, testcase_id, 'match-1'))
        self.delete_at_teardown.append(
            add_user(self.connection, testcase_id, 'match-2'))
        self.delete_at_teardown.append(
            add_user(self.connection, testcase_id, 'match-3'))
        o = ObjectDef('inetOrgPerson')
        o += AttrDef('cn', 'Common Name')
        o += AttrDef('sn', 'Surname')
        o += AttrDef('givenName', 'Given Name')

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

        results = r.search()
        self.assertEqual(len(results), 3)

        e = r.match_dn('match')  # multiple matches
        self.assertEqual(len(e), 3)
        e = r.match_dn('-2')  # single match
        self.assertEqual(len(e), 1)
        e = r.match_dn('no-match')  # no match
        self.assertEqual(len(e), 0)
Example #52
0
    def test_move_dn(self):
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'modify-dn-2'))
        counter = 20
        result = None
        while counter > 0:  # tries move operation for at maximum 20 times - partition may be busy while moving (at least on eDirectory)
            sleep(3)
            result = self.connection.modify_dn(self.delete_at_teardown[0][0], test_name_attr + '=' + testcase_id + 'modify-dn-2', new_superior=test_moved)
            if not self.connection.strategy.sync:
                _, result = self.connection.get_response(result)
            else:
                result = self.connection.result
            if result['description'] == 'success':
                break
            counter -= 1

        self.assertEqual('success', result['description'])
        self.delete_at_teardown[0] = (self.delete_at_teardown[0][0].replace(test_base, test_moved), self.delete_at_teardown[0][1])
 def setUp(self):
     self.connection = get_connection()
     self.delete_at_teardown = []
     if test_server_type == 'EDIR':
         self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-1', attributes={'givenName': 'givenname-1', test_int_attr: 0}))
         self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-2', attributes={'givenName': 'givenname-2', test_int_attr: 0}))
     elif test_server_type == 'AD':
         self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-1', attributes={'givenName': 'givenname-1'}))
         self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-2', attributes={'givenName': 'givenname-2'}))
     else:
         self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-1', attributes={'givenName': 'givenname-1'}))
         self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'search-2', attributes={'givenName': 'givenname-2'}))
Example #54
0
    def test_abort_transaction(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'))
            transaction_control = self.connection.extend.novell.start_transaction()
            self.connection.modify(self.delete_at_teardown[0][0], {'givenName': (MODIFY_REPLACE, ['user-1b'])}, controls=[transaction_control])
            self.connection.modify(self.delete_at_teardown[0][0], {'sn': (MODIFY_REPLACE, ['sn-user-1b'])}, controls=[transaction_control])
            result = self.connection.extend.novell.end_transaction(commit=False, controls=[transaction_control])
            result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', attributes=['givenName', 'sn'])
            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.assertEquals(response[0]['attributes']['givenName'][0], 'user-1b')
                self.assertEquals(response[0]['attributes']['sn'][0], 'user-1')
            else:
                self.assertFalse(True, self.delete_at_teardown[0][0] + ' not found')
Example #55
0
    def test_invalid_transaction_cookie(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'))
            transaction_control = self.connection.extend.novell.start_transaction()
            invalid_transaction_control = build_control('2.16.840.1.113719.1.27.103.7', True, Integer(12345678), encode_control_value=True)
            self.connection.modify(self.delete_at_teardown[0][0], {'givenName': (MODIFY_REPLACE, ['user-1b'])}, controls=[transaction_control])
            self.connection.modify(self.delete_at_teardown[0][0], {'sn': (MODIFY_REPLACE, ['sn-user-1b'])}, controls=[invalid_transaction_control])
            result = self.connection.extend.novell.end_transaction(commit=True, controls=[transaction_control])
            result = self.connection.search(self.delete_at_teardown[0][0], '(objectclass=*)', attributes=['givenName', 'sn'])
            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.assertEquals(response[0]['attributes']['givenName'][0], 'user-1b')
                self.assertEquals(response[0]['attributes']['sn'][0], 'user-1')
            else:
                self.assertFalse(True, self.delete_at_teardown[0][0] + ' not found')
Example #56
0
    def test_search_deleted_objects_ad(self):
        if test_server_type == 'AD':
            dn_to_delete, _ = add_user(self.connection, testcase_id, 'to-be-deleted-1', attributes={'givenName': 'to-be-deleted-1'})
            sleep(1)
            self.connection.delete(dn_to_delete)
            sleep(1)
            result = self.connection.search(search_base=test_root_partition,
                                            search_filter='(&(isDeleted=TRUE)(cn=*' + testcase_id + '*deleted-1*))',
                                            search_scope=SUBTREE,
                                            attributes=[],
                                            controls=[show_deleted_control(criticality=True)])
            if not self.connection.strategy.sync:
                response, result = self.connection.get_response(result)
            else:
                response = self.connection.response
                result = self.connection.result
            found = False
            for entry in response:
                if entry['type'] == 'searchResEntry' and testcase_id in entry['dn']:
                    found = True
                    break

            self.assertTrue(found)
Example #57
0
    def test_dir_sync(self):
        if test_server_type == 'AD':
            sync = self.connection.extend.microsoft.dir_sync(test_root_partition, attributes=['*'])
            # read all previous changes
            while sync.more_results:
                print('PREV', len(sync.loop()))

            # add a new object and verify the sync
            dn, _ = add_user(self.connection, testcase_id, 'to-be-deleted-1', attributes={'givenName': 'to-be-deleted-1'})
            sleep(1)
            response = sync.loop()
            print('ADD OBJ', len(response), response[0]['attributes'])
            found = False
            for entry in response:
                if entry['type'] == 'searchResEntry' and testcase_id + 'to-be-deleted-1' in entry['dn']:
                    found = True
                    break
            self.assertTrue(found)

            # modify-add an attribute and verify the sync
            result = self.connection.modify(dn, {'businessCategory': (MODIFY_ADD, ['businessCategory-1-added'])})
            if not self.connection.strategy.sync:
                _, result = self.connection.get_response(result)
            else:
                result = self.connection.result
            self.assertEqual(result['description'], 'success')
            sleep(1)
            response = sync.loop()
            print('MOD-ADD ATTR', len(response), response[0]['attributes'])
            found = False
            for entry in response:
                if entry['type'] == 'searchResEntry' and testcase_id + 'to-be-deleted-1' in entry['dn']:
                    found = True
                    break
            self.assertTrue(found)

            # modify-replace an attribute and verify the sync
            result = self.connection.modify(dn, {'businessCategory': (MODIFY_REPLACE, ['businessCategory-1-replaced']), 'sn': (MODIFY_REPLACE, ['sn-replaced'])})
            if not self.connection.strategy.sync:
                _, result = self.connection.get_response(result)
            else:
                result = self.connection.result
            self.assertEqual(result['description'], 'success')
            sleep(1)
            response = sync.loop()
            print('MOD-REPLACE ATTR', len(response), response[0]['attributes'])
            found = False
            for entry in response:
                if entry['type'] == 'searchResEntry' and testcase_id + 'to-be-deleted-1' in entry['dn']:
                    found = True
                    break
            self.assertTrue(found)

            # modify-delete an attribute and verify the sync
            # result = self.connection.modify(dn, {'businessCategory': (MODIFY_ADD, ['businessCategory-2-added', 'businessCategory-3-added'])})
            # if not self.connection.strategy.sync:
            #     _, result = self.connection.get_response(result)
            # else:
            #     result = self.connection.result
            # self.assertEqual(result['description'], 'success')
            result = self.connection.modify(dn, {'businessCategory': (MODIFY_DELETE, ['businessCategory-1-replaced'])})
            if not self.connection.strategy.sync:
                _, result = self.connection.get_response(result)
            else:
                result = self.connection.result
            self.assertEqual(result['description'], 'success')
            sleep(1)
            response = sync.loop()
            print('MOD-DEL ATTR', len(response), response[0]['attributes'])
            found = False
            for entry in response:
                if entry['type'] == 'searchResEntry' and testcase_id + 'to-be-deleted-1' in entry['dn']:
                    found = True
                    break
            self.assertTrue(found)

            # delete object and verify the sync
            self.connection.delete(dn)
            sleep(1)
            response = sync.loop()
            print('DEL OBJ', len(response), response[0]['attributes'])
            found = False
            for entry in response:
                if entry['type'] == 'searchResEntry' and testcase_id + 'to-be-deleted-1' in entry['dn']:
                    found = True
                    break

            self.assertTrue(found)
Example #58
0
    def test_add(self):
        self.delete_at_teardown.append(add_user(self.connection, testcase_id, 'add-operation-1'))

        self.assertEqual('success', self.delete_at_teardown[0][1]['description'])