ldap: remove not used test reference for ldap library

rhodecode/tests/__init__.py

@@ -1,247 +1,236 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
 import time
 import logging
 import datetime
 import hashlib
 import tempfile
 from os.path import join as jn
 
 from tempfile import _RandomNameSequence
 
 import pytest
 
 from rhodecode.model.db import User
 from rhodecode.lib import auth
 from rhodecode.lib import helpers as h
 from rhodecode.lib.helpers import flash, link_to
 from rhodecode.lib.utils2 import safe_str
 
 
 log = logging.getLogger(__name__)
 
 __all__ = [
     'get_new_dir', 'TestController',
-    'link_to', 'ldap_lib_installed', 'clear_all_caches',
+    'link_to', 'clear_all_caches',
     'assert_session_flash', 'login_user', 'no_newline_id_generator',
     'TESTS_TMP_PATH', 'HG_REPO', 'GIT_REPO', 'SVN_REPO',
     'NEW_HG_REPO', 'NEW_GIT_REPO',
     'HG_FORK', 'GIT_FORK', 'TEST_USER_ADMIN_LOGIN', 'TEST_USER_ADMIN_PASS',
     'TEST_USER_REGULAR_LOGIN', 'TEST_USER_REGULAR_PASS',
     'TEST_USER_REGULAR_EMAIL', 'TEST_USER_REGULAR2_LOGIN',
     'TEST_USER_REGULAR2_PASS', 'TEST_USER_REGULAR2_EMAIL', 'TEST_HG_REPO',
     'TEST_HG_REPO_CLONE', 'TEST_HG_REPO_PULL', 'TEST_GIT_REPO',
     'TEST_GIT_REPO_CLONE', 'TEST_GIT_REPO_PULL', 'SCM_TESTS',
 ]
 
 
 # SOME GLOBALS FOR TESTS
 TEST_DIR = tempfile.gettempdir()
 
 TESTS_TMP_PATH = jn(TEST_DIR, 'rc_test_%s' % _RandomNameSequence().next())
 TEST_USER_ADMIN_LOGIN = 'test_admin'
 TEST_USER_ADMIN_PASS = 'test12'
 TEST_USER_ADMIN_EMAIL = '[e-mail]'
 
 TEST_USER_REGULAR_LOGIN = 'test_regular'
 TEST_USER_REGULAR_PASS = 'test12'
 TEST_USER_REGULAR_EMAIL = '[e-mail]'
 
 TEST_USER_REGULAR2_LOGIN = 'test_regular2'
 TEST_USER_REGULAR2_PASS = 'test12'
 TEST_USER_REGULAR2_EMAIL = '[e-mail]'
 
 HG_REPO = 'vcs_test_hg'
 GIT_REPO = 'vcs_test_git'
 SVN_REPO = 'vcs_test_svn'
 
 NEW_HG_REPO = 'vcs_test_hg_new'
 NEW_GIT_REPO = 'vcs_test_git_new'
 
 HG_FORK = 'vcs_test_hg_fork'
 GIT_FORK = 'vcs_test_git_fork'
 
 ## VCS
 SCM_TESTS = ['hg', 'git']
 uniq_suffix = str(int(time.mktime(datetime.datetime.now().timetuple())))
 
 TEST_GIT_REPO = jn(TESTS_TMP_PATH, GIT_REPO)
 TEST_GIT_REPO_CLONE = jn(TESTS_TMP_PATH, 'vcsgitclone%s' % uniq_suffix)
 TEST_GIT_REPO_PULL = jn(TESTS_TMP_PATH, 'vcsgitpull%s' % uniq_suffix)
 
 TEST_HG_REPO = jn(TESTS_TMP_PATH, HG_REPO)
 TEST_HG_REPO_CLONE = jn(TESTS_TMP_PATH, 'vcshgclone%s' % uniq_suffix)
 TEST_HG_REPO_PULL = jn(TESTS_TMP_PATH, 'vcshgpull%s' % uniq_suffix)
 
 TEST_REPO_PREFIX = 'vcs-test'
 
 
-# skip ldap tests if LDAP lib is not installed
-ldap_lib_installed = False
-try:
-    import ldap
-    ldap_lib_installed = True
-except ImportError:
-    ldap = None
-    # means that python-ldap is not installed
-    pass
-
-
 def clear_all_caches():
     from beaker.cache import cache_managers
     for _cache in cache_managers.values():
         _cache.clear()
 
 
 def get_new_dir(title):
     """
     Returns always new directory path.
     """
     from rhodecode.tests.vcs.utils import get_normalized_path
     name_parts = [TEST_REPO_PREFIX]
     if title:
         name_parts.append(title)
     hex_str = hashlib.sha1('%s %s' % (os.getpid(), time.time())).hexdigest()
     name_parts.append(hex_str)
     name = '-'.join(name_parts)
     path = os.path.join(TEST_DIR, name)
     return get_normalized_path(path)
 
 
 @pytest.mark.usefixtures('app', 'index_location')
 class TestController(object):
 
     maxDiff = None
 
     def log_user(self, username=TEST_USER_ADMIN_LOGIN,
                  password=TEST_USER_ADMIN_PASS):
         self._logged_username = username
         self._session = login_user_session(self.app, username, password)
         self.csrf_token = auth.get_csrf_token(self._session)
 
         return self._session['rhodecode_user']
 
     def logout_user(self):
         logout_user_session(self.app, auth.get_csrf_token(self._session))
         self.csrf_token = None
         self._logged_username = None
         self._session = None
 
     def _get_logged_user(self):
         return User.get_by_username(self._logged_username)
 
 
 def login_user_session(
         app, username=TEST_USER_ADMIN_LOGIN, password=TEST_USER_ADMIN_PASS):
 
     response = app.post(
         h.route_path('login'),
         {'username': username, 'password': password})
     if 'invalid user name' in response.body:
         pytest.fail('could not login using %s %s' % (username, password))
 
     assert response.status == '302 Found'
     response = response.follow()
     assert response.status == '200 OK'
 
     session = response.get_session_from_response()
     assert 'rhodecode_user' in session
     rc_user = session['rhodecode_user']
     assert rc_user.get('username') == username
     assert rc_user.get('is_authenticated')
 
     return session
 
 
 def logout_user_session(app, csrf_token):
     app.post(h.route_path('logout'), {'csrf_token': csrf_token}, status=302)
 
 
 def login_user(app, username=TEST_USER_ADMIN_LOGIN,
                password=TEST_USER_ADMIN_PASS):
     return login_user_session(app, username, password)['rhodecode_user']
 
 
 def assert_session_flash(response, msg=None, category=None, no_=None):
     """
     Assert on a flash message in the current session.
 
     :param response: Response from give calll, it will contain flash
         messages or bound session with them.
     :param msg: The expected message. Will be evaluated if a
         :class:`LazyString` is passed in.
     :param category: Optional. If passed, the message category will be
         checked as well.
     :param no_: Optional. If passed, the message will be checked to NOT
         be in the flash session
     """
     if msg is None and no_ is None:
         raise ValueError("Parameter msg or no_ is required.")
 
     if msg and no_:
         raise ValueError("Please specify either msg or no_, but not both")
 
     session = response.get_session_from_response()
     messages = flash.pop_messages(session=session)
     msg = _eval_if_lazy(msg)
 
     if no_:
         error_msg = 'unable to detect no_ message `%s` in empty flash list' % no_
     else:
         error_msg = 'unable to find message `%s` in empty flash list' % msg
     assert messages, error_msg
     message = messages[0]
 
     message_text = _eval_if_lazy(message.message) or ''
 
     if no_:
         if no_ in message_text:
             msg = u'msg `%s` found in session flash.' % (no_,)
             pytest.fail(safe_str(msg))
     else:
         if msg not in message_text:
             fail_msg = u'msg `%s` not found in session ' \
                        u'flash: got `%s` (type:%s) instead' % (
                 msg, message_text, type(message_text))
 
             pytest.fail(safe_str(fail_msg))
         if category:
             assert category == message.category
 
 
 def _eval_if_lazy(value):
     return value.eval() if hasattr(value, 'eval') else value
 
 
 def no_newline_id_generator(test_name):
     """
     Generates a test name without spaces or newlines characters. Used for
     nicer output of progress of test
     """
     org_name = test_name
     test_name = test_name\
         .replace('\n', '_N') \
         .replace('\r', '_N') \
         .replace('\t', '_T') \
         .replace(' ', '_S')
 
     return test_name or 'test-with-empty-name'

rhodecode/tests/other/test_validators.py

@@ -1,295 +1,294 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import formencode
 import pytest
 
 from rhodecode.tests import (
     HG_REPO, TEST_USER_REGULAR2_EMAIL, TEST_USER_REGULAR2_LOGIN,
-    TEST_USER_REGULAR2_PASS, TEST_USER_ADMIN_LOGIN, TESTS_TMP_PATH,
-    ldap_lib_installed)
+    TEST_USER_REGULAR2_PASS, TEST_USER_ADMIN_LOGIN, TESTS_TMP_PATH)
 
 from rhodecode.model import validators as v
 from rhodecode.model.user_group import UserGroupModel
 
 from rhodecode.model.meta import Session
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.db import ChangesetStatus, Repository
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.tests.fixture import Fixture
 
 fixture = Fixture()
 
 pytestmark = pytest.mark.usefixtures('baseapp')
 
 
 @pytest.fixture
 def localizer():
     def func(msg):
         return msg
     return func
 
 
 def test_Message_extractor(localizer):
     validator = v.ValidUsername(localizer)
     pytest.raises(formencode.Invalid, validator.to_python, 'default')
 
     class StateObj(object):
         pass
 
     pytest.raises(
         formencode.Invalid, validator.to_python, 'default', StateObj)
 
 
 def test_ValidUsername(localizer):
     validator = v.ValidUsername(localizer)
 
     pytest.raises(formencode.Invalid, validator.to_python, 'default')
     pytest.raises(formencode.Invalid, validator.to_python, 'new_user')
     pytest.raises(formencode.Invalid, validator.to_python, '.,')
     pytest.raises(
         formencode.Invalid, validator.to_python, TEST_USER_ADMIN_LOGIN)
     assert 'test' == validator.to_python('test')
 
     validator = v.ValidUsername(localizer, edit=True, old_data={'user_id': 1})
 
 
 def test_ValidRepoUser(localizer):
     validator = v.ValidRepoUser(localizer)
     pytest.raises(formencode.Invalid, validator.to_python, 'nouser')
     assert TEST_USER_ADMIN_LOGIN == \
         validator.to_python(TEST_USER_ADMIN_LOGIN)
 
 
 def test_ValidUserGroup(localizer):
     validator = v.ValidUserGroup(localizer)
     pytest.raises(formencode.Invalid, validator.to_python, 'default')
     pytest.raises(formencode.Invalid, validator.to_python, '.,')
 
     gr = fixture.create_user_group('test')
     gr2 = fixture.create_user_group('tes2')
     Session().commit()
     pytest.raises(formencode.Invalid, validator.to_python, 'test')
     assert gr.users_group_id is not None
     validator = v.ValidUserGroup(localizer,
         edit=True,
         old_data={'users_group_id': gr2.users_group_id})
 
     pytest.raises(formencode.Invalid, validator.to_python, 'test')
     pytest.raises(formencode.Invalid, validator.to_python, 'TesT')
     pytest.raises(formencode.Invalid, validator.to_python, 'TEST')
     UserGroupModel().delete(gr)
     UserGroupModel().delete(gr2)
     Session().commit()
 
 
 @pytest.fixture(scope='function')
 def repo_group(request):
     model = RepoGroupModel()
     gr = model.create(
         group_name='test_gr', group_description='desc', just_db=True,
         owner=TEST_USER_ADMIN_LOGIN)
 
     def cleanup():
         model.delete(gr)
 
     request.addfinalizer(cleanup)
 
     return gr
 
 
 def test_ValidRepoGroup_same_name_as_repo(localizer):
     validator = v.ValidRepoGroup(localizer)
     with pytest.raises(formencode.Invalid) as excinfo:
         validator.to_python({'group_name': HG_REPO})
     expected_msg = 'Repository with name "vcs_test_hg" already exists'
     assert expected_msg in str(excinfo.value)
 
 
 def test_ValidRepoGroup_group_exists(localizer, repo_group):
     validator = v.ValidRepoGroup(localizer)
     with pytest.raises(formencode.Invalid) as excinfo:
         validator.to_python({'group_name': repo_group.group_name})
     expected_msg = 'Group "test_gr" already exists'
     assert expected_msg in str(excinfo.value)
 
 
 def test_ValidRepoGroup_invalid_parent(localizer, repo_group):
     validator = v.ValidRepoGroup(localizer, edit=True,
                                  old_data={'group_id': repo_group.group_id})
     with pytest.raises(formencode.Invalid) as excinfo:
         validator.to_python({
             'group_name': repo_group.group_name + 'n',
             'group_parent_id': repo_group.group_id,
         })
     expected_msg = 'Cannot assign this group as parent'
     assert expected_msg in str(excinfo.value)
 
 
 def test_ValidRepoGroup_edit_group_no_root_permission(localizer, repo_group):
     validator = v.ValidRepoGroup(localizer,
         edit=True, old_data={'group_id': repo_group.group_id},
         can_create_in_root=False)
 
     # Cannot change parent
     with pytest.raises(formencode.Invalid) as excinfo:
         validator.to_python({'group_parent_id': '25'})
     expected_msg = 'no permission to store repository group in root location'
     assert expected_msg in str(excinfo.value)
 
     # Chaning all the other fields is allowed
     validator.to_python({'group_name': 'foo', 'group_parent_id': '-1'})
     validator.to_python(
         {'user': TEST_USER_REGULAR2_LOGIN, 'group_parent_id': '-1'})
     validator.to_python({'group_description': 'bar', 'group_parent_id': '-1'})
     validator.to_python({'enable_locking': 'true', 'group_parent_id': '-1'})
 
 
 def test_ValidPassword(localizer):
     validator = v.ValidPassword(localizer)
     assert 'lol' == validator.to_python('lol')
     assert None == validator.to_python(None)
     pytest.raises(formencode.Invalid, validator.to_python, 'ąćżź')
 
 
 def test_ValidPasswordsMatch(localizer):
     validator = v.ValidPasswordsMatch(localizer)
     pytest.raises(
         formencode.Invalid,
         validator.to_python, {'password': 'pass',
                               'password_confirmation': 'pass2'})
 
     pytest.raises(
         formencode.Invalid,
         validator.to_python, {'new_password': 'pass',
                               'password_confirmation': 'pass2'})
 
     assert {'new_password': 'pass', 'password_confirmation': 'pass'} == \
         validator.to_python({'new_password': 'pass',
                              'password_confirmation': 'pass'})
 
     assert {'password': 'pass', 'password_confirmation': 'pass'} == \
         validator.to_python({'password': 'pass',
                              'password_confirmation': 'pass'})
 
 
 def test_ValidAuth(localizer, config_stub):
     config_stub.testing_securitypolicy()
     config_stub.include('rhodecode.authentication')
 
     validator = v.ValidAuth(localizer)
     valid_creds = {
         'username': TEST_USER_REGULAR2_LOGIN,
         'password': TEST_USER_REGULAR2_PASS,
     }
     invalid_creds = {
         'username': 'err',
         'password': 'err',
     }
     assert valid_creds == validator.to_python(valid_creds)
     pytest.raises(
         formencode.Invalid, validator.to_python, invalid_creds)
 
 
 def test_ValidRepoName(localizer):
     validator = v.ValidRepoName(localizer)
 
     pytest.raises(
         formencode.Invalid, validator.to_python, {'repo_name': ''})
 
     pytest.raises(
         formencode.Invalid, validator.to_python, {'repo_name': HG_REPO})
 
     gr = RepoGroupModel().create(group_name='group_test',
                                  group_description='desc',
                                  owner=TEST_USER_ADMIN_LOGIN)
     pytest.raises(
         formencode.Invalid, validator.to_python, {'repo_name': gr.group_name})
 
     #TODO: write an error case for that ie. create a repo withinh a group
 #        pytest.raises(formencode.Invalid,
 #                          validator.to_python, {'repo_name': 'some',
 #                                                'repo_group': gr.group_id})
 
 
 def test_ValidForkName(localizer):
     # this uses ValidRepoName validator
     assert True
 
 @pytest.mark.parametrize("name, expected", [
     ('test', 'test'), ('lolz!', 'lolz'), ('  aavv', 'aavv'),
     ('ala ma kota', 'ala-ma-kota'), ('@nooo', 'nooo'),
     ('$!haha lolz !', 'haha-lolz'), ('$$$$$', ''), ('{}OK!', 'OK'),
     ('/]re po', 're-po')])
 def test_SlugifyName(name, expected, localizer):
     validator = v.SlugifyName(localizer)
     assert expected == validator.to_python(name)
 
 
 def test_ValidForkType(localizer):
         validator = v.ValidForkType(localizer, old_data={'repo_type': 'hg'})
         assert 'hg' == validator.to_python('hg')
         pytest.raises(formencode.Invalid, validator.to_python, 'git')
 
 
 def test_ValidPath(localizer):
         validator = v.ValidPath(localizer)
         assert TESTS_TMP_PATH == validator.to_python(TESTS_TMP_PATH)
         pytest.raises(
             formencode.Invalid, validator.to_python, '/no_such_dir')
 
 
 def test_UniqSystemEmail(localizer):
     validator = v.UniqSystemEmail(localizer, old_data={})
 
     assert '[e-mail]' == validator.to_python('[e-mail]')
 
     email = TEST_USER_REGULAR2_EMAIL
     pytest.raises(formencode.Invalid, validator.to_python, email)
 
 
 def test_ValidSystemEmail(localizer):
     validator = v.ValidSystemEmail(localizer)
     email = TEST_USER_REGULAR2_EMAIL
 
     assert email == validator.to_python(email)
     pytest.raises(formencode.Invalid, validator.to_python, 'err')
 
 
 def test_NotReviewedRevisions(localizer):
     repo_id = Repository.get_by_repo_name(HG_REPO).repo_id
     validator = v.NotReviewedRevisions(localizer, repo_id)
     rev = '0' * 40
     # add status for a rev, that should throw an error because it is already
     # reviewed
     new_status = ChangesetStatus()
     new_status.author = ChangesetStatusModel()._get_user(TEST_USER_ADMIN_LOGIN)
     new_status.repo = ChangesetStatusModel()._get_repo(HG_REPO)
     new_status.status = ChangesetStatus.STATUS_APPROVED
     new_status.comment = None
     new_status.revision = rev
     Session().add(new_status)
     Session().commit()
     try:
         pytest.raises(formencode.Invalid, validator.to_python, [rev])
     finally:
         Session().delete(new_status)
         Session().commit()