class ValidAuthToken(formencode.validators.FancyValidator):

    messages = {'invalid_token':_('Token mismatch')}

    def validate_python(self, value, state):

        if value != authentication_token():

            raise formencode.Invalid(self.message('invalid_token', state,

                                            search_number=value), value, state)

def ValidUsername(edit, old_data):

    class _ValidUsername(formencode.validators.FancyValidator):

        def validate_python(self, value, state):

            if value in ['default', 'new_user']:

                raise formencode.Invalid(_('Invalid username'), value, state)

            #check if user is unique

            old_un = None

            if edit:

                old_un = UserModel().get(old_data.get('user_id')).username

            if old_un != value or not edit:

                if UserModel().get_by_username(value, cache=False):

                    raise formencode.Invalid(_('This username already exists') ,

                                             value, state)

    return _ValidUsername

class ValidPassword(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        if value:

            if value.get('password'):

                try:

                    value['password'] = get_crypt_password(value['password'])

                except UnicodeEncodeError:

                    e_dict = {'password':_('Invalid characters in password')}

                    raise formencode.Invalid('', value, state, error_dict=e_dict)

            if value.get('password_confirmation'):

                try:

                    value['password_confirmation'] = \

                        get_crypt_password(value['password_confirmation'])

                except UnicodeEncodeError:

                    e_dict = {'password_confirmation':_('Invalid characters in password')}

                    raise formencode.Invalid('', value, state, error_dict=e_dict)

            return value

class ValidPasswordsMatch(formencode.validators.FancyValidator):

    def validate_python(self, value, state):

        if value['password'] != value['password_confirmation']:

            e_dict = {'password_confirmation':

                   _('Password do not match')}

            raise formencode.Invalid('', value, state, error_dict=e_dict)

class ValidAuth(formencode.validators.FancyValidator):

    messages = {

            'invalid_password':_('invalid password'),

            'invalid_login':_('invalid user name'),

            'disabled_account':_('Your account is disabled')

            }

    #error mapping

    e_dict = {'username':messages['invalid_login'],

              'password':messages['invalid_password']}

    e_dict_disable = {'username':messages['disabled_account']}

    def validate_python(self, value, state):

        password = value['password']

        username = value['username']

        user = UserModel().get_by_username(username)

        if authfunc(None, username, password):

            return value

        else:

            if user and user.active is False:

                log.warning('user %s is disabled', username)

                raise formencode.Invalid(self.message('disabled_account',

                                         state=State_obj),

                                         value, state,

                                         error_dict=self.e_dict_disable)

            else:

                log.warning('user %s not authenticated', username)

                raise formencode.Invalid(self.message('invalid_password',

                                         state=State_obj), value, state,

                                         error_dict=self.e_dict)

class ValidRepoUser(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        sa = meta.Session()

        try:

from rhodecode.model.db import Repository

from rhodecode.tests import *

class TestAdminReposController(TestController):

    def test_index(self):

        self.log_user()

        response = self.app.get(url('repos'))

        # Test response...

    def test_index_as_xml(self):

        response = self.app.get(url('formatted_repos', format='xml'))

    def test_create_hg(self):

        self.log_user()

        repo_name = NEW_HG_REPO

        description = 'description for newly created repo'

        private = False

        response = self.app.post(url('repos'), {'repo_name':repo_name,

                                                'repo_type':'hg',

                                                'description':description,

                                                'private':private})

        #test if we have a message for that repository

        assert '''created repository %s''' % (repo_name) in response.session['flash'][0], 'No flash message about new repo'

        #test if the fork was created in the database

        new_repo = self.sa.query(Repository).filter(Repository.repo_name == repo_name).one()

        assert new_repo.repo_name == repo_name, 'wrong name of repo name in db'

        assert new_repo.description == description, 'wrong description'

        #test if repository is visible in the list ?

        response = response.follow()

        assert repo_name in response.body, 'missing new repo from the main repos list'

    def test_create_git(self):

        self.log_user()

        repo_name = NEW_GIT_REPO

        description = 'description for newly created repo'

        private = False

        response = self.app.post(url('repos'), {'repo_name':repo_name,

                                                'repo_type':'git',

                                                'description':description,

                                                'private':private})

        #test if we have a message for that repository

        assert '''created repository %s''' % (repo_name) in response.session['flash'][0], 'No flash message about new repo'

        #test if the fork was created in the database

        new_repo = self.sa.query(Repository).filter(Repository.repo_name == repo_name).one()

        assert new_repo.repo_name == repo_name, 'wrong name of repo name in db'

        assert new_repo.description == description, 'wrong description'

        #test if repository is visible in the list ?

        response = response.follow()

        assert repo_name in response.body, 'missing new repo from the main repos list'

    def test_new(self):

        self.log_user()

        response = self.app.get(url('new_repo'))

    def test_new_as_xml(self):

        response = self.app.get(url('formatted_new_repo', format='xml'))

    def test_update(self):

        response = self.app.put(url('repo', repo_name=HG_REPO))

    def test_update_browser_fakeout(self):

        response = self.app.post(url('repo', repo_name=HG_REPO), params=dict(_method='put'))

    def test_delete(self):

        self.log_user()

        repo_name = 'vcs_test_new_to_delete'

        description = 'description for newly created repo'

        private = False

        response = self.app.post(url('repos'), {'repo_name':repo_name,

                                                'repo_type':'hg',

                                               'description':description,

                                               'private':private})

from rhodecode.tests import *

from rhodecode.model.db import User

from rhodecode.lib.auth import check_password

class TestLoginController(TestController):

    def test_index(self):

        response = self.app.get(url(controller='login', action='index'))

        assert response.status == '200 OK', 'Wrong response from login page got %s' % response.status

        # Test response...

    def test_login_admin_ok(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'test_admin',

                                  'password':'test12'})

        assert response.status == '302 Found', 'Wrong response code from login got %s' % response.status

        assert response.session['rhodecode_user'].username == 'test_admin', 'wrong logged in user'

        response = response.follow()

        assert '%s repository' % HG_REPO in response.body

    def test_login_regular_ok(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'test_regular',

                                  'password':'test12'})

        print response

        assert response.status == '302 Found', 'Wrong response code from login got %s' % response.status

        assert response.session['rhodecode_user'].username == 'test_regular', 'wrong logged in user'

        response = response.follow()

        assert '%s repository' % HG_REPO in response.body

        assert '<a title="Admin" href="/_admin">' not in response.body

    def test_login_ok_came_from(self):

        test_came_from = '/_admin/users'

        response = self.app.post(url(controller='login', action='index', came_from=test_came_from),

                                 {'username':'test_admin',

                                  'password':'test12'})

        assert response.status == '302 Found', 'Wrong response code from came from redirection'

        response = response.follow()

        assert response.status == '200 OK', 'Wrong response from login page got %s' % response.status

        assert 'Users administration' in response.body, 'No proper title in response'

    def test_login_short_password(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'error',

                                  'password':'test'})

        assert response.status == '200 OK', 'Wrong response from login page'

        print response.body

        assert 'Enter 6 characters or more' in response.body, 'No error password message in response'

    def test_login_wrong_username_password(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'error',

                                  'password':'test12'})

        assert response.status == '200 OK', 'Wrong response from login page'

        assert 'invalid user name' in response.body, 'No error username message in response'

        assert 'invalid password' in response.body, 'No error password message in response'

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

    # REGISTRATIONS

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

    def test_register(self):

        response = self.app.get(url(controller='login', action='register'))

    def test_register_err_same_username(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'test_admin',

                                             'password':'test12',

                                             'password_confirmation':'test12',

                                             'email':'goodmail@domain.com',

                                             'name':'test',

                                             'lastname':'test'})

        assert response.status == '200 OK', 'Wrong response from register page got %s' % response.status

        assert 'This username already exists' in response.body

    def test_register_err_wrong_data(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'xs',

                                             'password':'test',

                                             'password_confirmation':'test',

                                             'email':'goodmailm',

                                             'name':'test',

                                             'lastname':'test'})

        assert response.status == '200 OK', 'Wrong response from register page got %s' % response.status

        assert 'An email address must contain a single @' in response.body

    def test_register_special_chars(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'xxxaxn',

                                             'password':'ąćźżąśśśś',

                                             'password_confirmation':'ąćźżąśśśś',

                                             'name':'test',

        assert response.status == '200 OK', 'Wrong response from register page got %s' % response.status

        assert 'Invalid characters in password' in response.body

    def test_register_password_mismatch(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'xs',

                                             'password':'123qwe',

                                             'password_confirmation':'qwe123',

                                             'name':'test',

        assert response.status == '200 OK', 'Wrong response from register page got %s' % response.status

        assert 'Password do not match' in response.body

    def test_register_ok(self):

        username = 'test_regular4'

        password = 'qweqwe'

        email = 'marcin@test.com'

        name = 'testname'

        lastname = 'testlastname'

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':username,

                                             'password':password,

                                             'password_confirmation':password,

                                             'email':email,

                                             'name':name,

                                             'lastname':lastname})

        assert response.status == '302 Found', 'Wrong response from register page got %s' % response.status

        assert 'You have successfully registered into rhodecode' in response.session['flash'][0], 'No flash message about user registration'

        ret = self.sa.query(User).filter(User.username == 'test_regular4').one()

        assert ret.username == username , 'field mismatch %s %s' % (ret.username, username)

        assert check_password(password, ret.password) == True , 'password mismatch'

        assert ret.email == email , 'field mismatch %s %s' % (ret.email, email)

        assert ret.name == name , 'field mismatch %s %s' % (ret.name, name)

        assert ret.lastname == lastname , 'field mismatch %s %s' % (ret.lastname, lastname)

    def test_forgot_password_wrong_mail(self):

        response = self.app.post(url(controller='login', action='password_reset'),

                                            {'email':'marcin@wrongmail.org', })

        assert "That e-mail address doesn't exist" in response.body, 'Missing error message about wrong email'

    def test_forgot_password(self):

        response = self.app.get(url(controller='login', action='password_reset'))

        assert response.status == '200 OK', 'Wrong response from login page got %s' % response.status

        username = 'test_password_reset_1'

        password = 'qweqwe'

        email = 'marcin@python-works.com'

        name = 'passwd'

        lastname = 'reset'

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':username,

                                             'password':password,

                                             'email':email,

                                             'name':name,

                                             'lastname':lastname})

        #register new user for email test

        response = self.app.post(url(controller='login', action='password_reset'),

                                            {'email':email, })

        print response.session['flash']

        assert 'You have successfully registered into rhodecode' in response.session['flash'][0], 'No flash message about user registration'

        assert 'Your new password was sent' in response.session['flash'][1], 'No flash message about password reset'

from rhodecode.model.db import Repository

from rhodecode.tests import *

class TestSettingsController(TestController):

    def test_index(self):

        self.log_user()

        response = self.app.get(url(controller='settings', action='index',

                                    repo_name=HG_REPO))

        # Test response...

    def test_fork(self):

        self.log_user()

        response = self.app.get(url(controller='settings', action='fork',

                                    repo_name=HG_REPO))

    def test_fork_create(self):

        self.log_user()

        fork_name = HG_FORK

        description = 'fork of vcs test'

        repo_name = HG_REPO

        response = self.app.post(url(controller='settings', action='fork_create',

                                    repo_name=repo_name),

                                    {'fork_name':fork_name,

                                     'repo_type':'hg',

                                     'description':description,

                                     'private':'False'})

        #test if we have a message that fork is ok

                      % (repo_name, fork_name) in response.session['flash'][0], 'No flash message about fork'

        #test if the fork was created in the database

        fork_repo = self.sa.query(Repository).filter(Repository.repo_name == fork_name).one()

        assert fork_repo.repo_name == fork_name, 'wrong name of repo name in new db fork repo'

        assert fork_repo.fork.repo_name == repo_name, 'wrong fork parrent'

        #test if fork is visible in the list ?

        response = response.follow()

        #check if fork is marked as fork

        response = self.app.get(url(controller='summary', action='index',

                                    repo_name=fork_name))

        assert 'Fork of %s' % repo_name in response.body, 'no message about that this repo is a fork'