raise Exception('Cannot set anonymous access')

#==============================================================================

# TESTS

#==============================================================================

def _check_proper_git_push(stdout, stderr):

    # WTF Git stderr is output ?!

    assert 'fatal' not in stderr

    assert 'rejected' not in stderr

    assert 'Pushing to' in stderr

    assert 'master -> master' in stderr

@pytest.mark.usefixtures("test_context_fixture")

class TestVCSOperations(TestController):

    @classmethod

    def setup_class(cls):

        # DISABLE ANONYMOUS ACCESS

        set_anonymous_access(False)

    def setup_method(self, method):

        r = Repository.get_by_repo_name(GIT_REPO)

        Repository.unlock(r)

        r.enable_locking = False

        Session().commit()

        r = Repository.get_by_repo_name(HG_REPO)

        Repository.unlock(r)

        r.enable_locking = False

        Session().commit()

    @pytest.fixture()

    def testhook_cleanup(self):

        yield

        # remove hook

        for hook in ['prechangegroup', 'pretxnchangegroup', 'preoutgoing', 'changegroup', 'outgoing', 'incoming']:

            entry = Ui.get_by_key('hooks', '%s.testhook' % hook)

            if entry:

                Session().delete(entry)

        Session().commit()

    @pytest.fixture(scope="module")

    def testfork(self):

        # create fork so the repo stays untouched

        fixture.create_fork(GIT_REPO, git_fork_name)

        fixture.create_fork(HG_REPO, hg_fork_name)

        return {'git': git_fork_name, 'hg': hg_fork_name}

    def test_clone_hg_repo_by_admin(self, webserver):

        clone_url = webserver.repo_url(HG_REPO)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('hg clone', clone_url, _get_tmp_dir())

        assert 'requesting all changes' in stdout

        assert 'adding changesets' in stdout

        assert 'adding manifests' in stdout

        assert 'adding file changes' in stdout

        assert stderr == ''

    def test_clone_git_repo_by_admin(self, webserver):

        clone_url = webserver.repo_url(GIT_REPO)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('git clone', clone_url, _get_tmp_dir())

        assert 'Cloning into' in stdout + stderr

        assert stderr == '' or stdout == ''

    def test_clone_wrong_credentials_hg(self, webserver):

        clone_url = webserver.repo_url(HG_REPO, password='bad!')

        stdout, stderr = Command(TESTS_TMP_PATH).execute('hg clone', clone_url, _get_tmp_dir(), ignoreReturnCode=True)

        assert 'abort: authorization failed' in stderr

    def test_clone_wrong_credentials_git(self, webserver):

        clone_url = webserver.repo_url(GIT_REPO, password='bad!')

        stdout, stderr = Command(TESTS_TMP_PATH).execute('git clone', clone_url, _get_tmp_dir(), ignoreReturnCode=True)

        assert 'fatal: Authentication failed' in stderr

    def test_clone_git_dir_as_hg(self, webserver):

        clone_url = webserver.repo_url(GIT_REPO)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('hg clone', clone_url, _get_tmp_dir(), ignoreReturnCode=True)

        assert 'HTTP Error 404: Not Found' in stderr

    def test_clone_hg_repo_as_git(self, webserver):

        clone_url = webserver.repo_url(HG_REPO)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('git clone', clone_url, _get_tmp_dir(), ignoreReturnCode=True)

        assert 'not found' in stderr

    def test_clone_non_existing_path_hg(self, webserver):

        clone_url = webserver.repo_url('trololo')

        stdout, stderr = Command(TESTS_TMP_PATH).execute('hg clone', clone_url, _get_tmp_dir(), ignoreReturnCode=True)

        assert 'HTTP Error 404: Not Found' in stderr

    def test_clone_non_existing_path_git(self, webserver):

        clone_url = webserver.repo_url('trololo')

        stdout, stderr = Command(TESTS_TMP_PATH).execute('git clone', clone_url, _get_tmp_dir(), ignoreReturnCode=True)

        assert 'not found' in stderr

    def test_push_new_file_hg(self, webserver):

        dest_dir = _get_tmp_dir()

        clone_url = webserver.repo_url(HG_REPO)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('hg clone', clone_url, dest_dir)

        fixture.create_fork(HG_REPO, fork_name)

        clone_url = webserver.repo_url(fork_name)

        stdout, stderr = _add_files_and_push(webserver, 'hg', dest_dir, clone_url=clone_url)

        assert 'pushing to' in stdout

        assert 'Repository size' in stdout

        assert 'Last revision is now' in stdout

    def test_push_new_file_git(self, webserver):

        dest_dir = _get_tmp_dir()

        clone_url = webserver.repo_url(GIT_REPO)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('git clone', clone_url, dest_dir)

        # commit some stuff into this repo

        fixture.create_fork(GIT_REPO, fork_name)

        clone_url = webserver.repo_url(fork_name)

        stdout, stderr = _add_files_and_push(webserver, 'git', dest_dir, clone_url=clone_url)

        print [(x.repo_full_path,x.repo_path) for x in Repository.query()] # TODO: what is this for

        _check_proper_git_push(stdout, stderr)

    def test_push_invalidates_cache_hg(self, webserver):

        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

                                               == HG_REPO).scalar()

        if not key:

            key = CacheInvalidation(HG_REPO, HG_REPO)

            Session().add(key)

        key.cache_active = True

        Session().commit()

        dest_dir = _get_tmp_dir()

        clone_url = webserver.repo_url(HG_REPO)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('hg clone', clone_url, dest_dir)

        fixture.create_fork(HG_REPO, fork_name)

        clone_url = webserver.repo_url(fork_name)

        stdout, stderr = _add_files_and_push(webserver, 'hg', dest_dir, files_no=1, clone_url=clone_url)

        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

                                               == fork_name).all()

        assert key == []

    def test_push_invalidates_cache_git(self, webserver):

        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

                                               == GIT_REPO).scalar()

        if not key:

            key = CacheInvalidation(GIT_REPO, GIT_REPO)

            Session().add(key)

        key.cache_active = True

        Session().commit()

        dest_dir = _get_tmp_dir()

        clone_url = webserver.repo_url(GIT_REPO)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('git clone', clone_url, dest_dir)

        # commit some stuff into this repo

        fixture.create_fork(GIT_REPO, fork_name)

        clone_url = webserver.repo_url(fork_name)

        stdout, stderr = _add_files_and_push(webserver, 'git', dest_dir, files_no=1, clone_url=clone_url)

        _check_proper_git_push(stdout, stderr)

        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

                                               == fork_name).all()

        assert key == []

    def test_push_wrong_credentials_hg(self, webserver):

        dest_dir = _get_tmp_dir()

        clone_url = webserver.repo_url(HG_REPO)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('hg clone', clone_url, dest_dir)

        stdout, stderr = _add_files_and_push(webserver, 'hg', dest_dir, username='bad',

                                             password='name', ignoreReturnCode=True)

        assert 'abort: authorization failed' in stderr

    def test_push_wrong_credentials_git(self, webserver):

        dest_dir = _get_tmp_dir()

        clone_url = webserver.repo_url(GIT_REPO)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('git clone', clone_url, dest_dir)

        stdout, stderr = _add_files_and_push(webserver, 'git', dest_dir, username='bad',

                                             password='name', ignoreReturnCode=True)

        assert 'fatal: Authentication failed' in stderr

    def test_push_with_readonly_credentials_hg(self, webserver):

        dest_dir = _get_tmp_dir()

        clone_url = webserver.repo_url(HG_REPO, username=TEST_USER_REGULAR_LOGIN, password=TEST_USER_REGULAR_PASS)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('hg clone', clone_url, dest_dir)

        stdout, stderr = _add_files_and_push(webserver, 'hg', dest_dir, username=TEST_USER_REGULAR_LOGIN,

                                             password=TEST_USER_REGULAR_PASS, ignoreReturnCode=True)

        assert 'abort: HTTP Error 403: Forbidden' in stderr

    def test_push_with_readonly_credentials_git(self, webserver):

        dest_dir = _get_tmp_dir()

        clone_url = webserver.repo_url(GIT_REPO, username=TEST_USER_REGULAR_LOGIN, password=TEST_USER_REGULAR_PASS)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('git clone', clone_url, dest_dir)

        stdout, stderr = _add_files_and_push(webserver, 'git', dest_dir, username=TEST_USER_REGULAR_LOGIN,

                                             password=TEST_USER_REGULAR_PASS, ignoreReturnCode=True)

        assert 'The requested URL returned error: 403' in stderr

                                          perm='repository.write')

        Session().commit()

        Repository.lock(r, User.get_by_username(TEST_USER_ADMIN_LOGIN).user_id)

        # push fails repo is locked by other user !

        stdout, stderr = _add_files_and_push(webserver, 'hg', dest_dir,

                                             username=TEST_USER_REGULAR_LOGIN,

                                             password=TEST_USER_REGULAR_PASS,

                                             ignoreReturnCode=True)

        msg = ("""abort: HTTP Error 423: Repository `%s` locked by user `%s`"""

                % (HG_REPO, TEST_USER_ADMIN_LOGIN))

        assert msg in stderr

    def test_push_on_locked_repo_by_other_user_git(self, webserver):

        # Note: Git hooks must be executable on unix. This test will thus fail

        # for example on Linux if /tmp is mounted noexec.

        # clone some temp

        dest_dir = _get_tmp_dir()

        clone_url = webserver.repo_url(GIT_REPO)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('git clone', clone_url, dest_dir)

        # lock repo

        r = Repository.get_by_repo_name(GIT_REPO)

        # let this user actually push !

        RepoModel().grant_user_permission(repo=r, user=TEST_USER_REGULAR_LOGIN,

                                          perm='repository.write')

        Session().commit()

        Repository.lock(r, User.get_by_username(TEST_USER_ADMIN_LOGIN).user_id)

        # push fails repo is locked by other user !

        stdout, stderr = _add_files_and_push(webserver, 'git', dest_dir,

                                             username=TEST_USER_REGULAR_LOGIN,

                                             password=TEST_USER_REGULAR_PASS,

                                             ignoreReturnCode=True)

        err = 'Repository `%s` locked by user `%s`' % (GIT_REPO, TEST_USER_ADMIN_LOGIN)

        assert err in stderr

        # TODO: fix this somehow later on Git, Git is stupid and even if we throw

        # back 423 to it, it makes ANOTHER request and we fail there with 405 :/

        msg = ("""abort: HTTP Error 423: Repository `%s` locked by user `%s`"""

                % (GIT_REPO, TEST_USER_ADMIN_LOGIN))

        #msg = "405 Method Not Allowed"

        #assert msg in stderr

    def test_push_unlocks_repository_hg(self, webserver):

        # enable locking

        fixture.create_fork(HG_REPO, fork_name)

        r = Repository.get_by_repo_name(fork_name)

        r.enable_locking = True

        Session().commit()

        # clone some temp

        dest_dir = _get_tmp_dir()

        clone_url = webserver.repo_url(fork_name)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('hg clone', clone_url, dest_dir)

        # check for lock repo after clone

        r = Repository.get_by_repo_name(fork_name)

        uid = User.get_by_username(TEST_USER_ADMIN_LOGIN).user_id

        assert r.locked[0] == uid

        # push is ok and repo is now unlocked

        stdout, stderr = _add_files_and_push(webserver, 'hg', dest_dir, clone_url=clone_url)

        assert str('remote: Released lock on repo `%s`' % fork_name) in stdout

        # we need to cleanup the Session Here !

        Session.remove()

        r = Repository.get_by_repo_name(fork_name)

        assert r.locked == [None, None]

    # TODO: fix me ! somehow during tests hooks don't get called on Git

    def test_push_unlocks_repository_git(self, webserver):

        # enable locking

        fixture.create_fork(GIT_REPO, fork_name)

        r = Repository.get_by_repo_name(fork_name)

        r.enable_locking = True

        Session().commit()

        # clone some temp

        dest_dir = _get_tmp_dir()

        clone_url = webserver.repo_url(fork_name)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('git clone', clone_url, dest_dir)

        # check for lock repo after clone

        r = Repository.get_by_repo_name(fork_name)

        assert r.locked[0] == User.get_by_username(TEST_USER_ADMIN_LOGIN).user_id

        # push is ok and repo is now unlocked

        stdout, stderr = _add_files_and_push(webserver, 'git', dest_dir, clone_url=clone_url)

        _check_proper_git_push(stdout, stderr)

        assert ('remote: Released lock on repo `%s`' % fork_name) in stderr

        # we need to cleanup the Session Here !

        Session.remove()

        r = Repository.get_by_repo_name(fork_name)

        assert r.locked == [None, None]

    def test_ip_restriction_hg(self, webserver):

        user_model = UserModel()

        try:

            user_model.add_extra_ip(TEST_USER_ADMIN_LOGIN, '10.10.10.10/32')

            Session().commit()

            clone_url = webserver.repo_url(HG_REPO)

            stdout, stderr = Command(TESTS_TMP_PATH).execute('hg clone', clone_url, _get_tmp_dir(), ignoreReturnCode=True)

            assert 'abort: HTTP Error 403: Forbidden' in stderr

        finally:

            # release IP restrictions

            for ip in UserIpMap.query():

                UserIpMap.delete(ip.ip_id)

            Session().commit()

        # IP permissions are cached, need to wait for the cache in the server process to expire

        time.sleep(1.5)

        clone_url = webserver.repo_url(HG_REPO)

        stdout, stderr = Command(TESTS_TMP_PATH).execute('hg clone', clone_url, _get_tmp_dir())

        assert 'requesting all changes' in stdout

        assert 'adding changesets' in stdout

        assert 'adding manifests' in stdout

        assert 'adding file changes' in stdout