self.checkSessionFlash(response,

                               'Created repository <a href="/%s">%s</a>'

                               % (repo_name, repo_name))

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == repo_name).one()

        self.assertEqual(new_repo.repo_name, repo_name)

        self.assertEqual(new_repo.description, description)

        #test if repository is visible in the list ?

        response = response.follow()

        response.mustcontain(repo_name)

        #test if repository was created on filesystem

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name))

        except Exception:

            self.fail('no repo %s in filesystem' % repo_name)

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

        response.follow()

        #check if repo was deleted from db

        deleted_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == repo_name).scalar()

        self.assertEqual(deleted_repo, None)

        self.assertEqual(os.path.isdir(os.path.join(TESTS_TMP_PATH, repo_name)),

                                  False)

    def test_delete_git(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'),

                        _get_repo_create_params(repo_private=False,

                                                repo_type='git',

                                                repo_name=repo_name,

                                                repo_description=description))

        self.checkSessionFlash(response,

                               'Created repository <a href="/%s">%s</a>'

                               % (repo_name, repo_name))

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == repo_name).one()

        self.assertEqual(new_repo.repo_name, repo_name)

        self.assertEqual(new_repo.description, description)

        #test if repository is visible in the list ?

        response = response.follow()

        response.mustcontain(repo_name)

        #test if repository was created on filesystem

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name))

        except Exception:

            self.fail('no repo %s in filesystem' % repo_name)

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

        response.follow()

        #check if repo was deleted from db

        deleted_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == repo_name).scalar()

        self.assertEqual(deleted_repo, None)

        self.assertEqual(os.path.isdir(os.path.join(TESTS_TMP_PATH, repo_name)),

                                  False)

    def test_delete_repo_with_group(self):

        #TODO:

        pass

    def test_delete_browser_fakeout(self):

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

                                 params=dict(_method='delete'))

    def test_show_hg(self):

        self.log_user()

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

                                                 rhodecode_ga_code=new_ga_code

                                                 ))

        self.checkSessionFlash(response, 'Updated application settings')

        self.assertEqual(RhodeCodeSetting

                         .get_app_settings()['rhodecode_ga_code'], new_ga_code)

        response = response.follow()

        response.mustcontain("""_gaq.push(['_setAccount', '%s']);""" % new_ga_code)

    def test_ga_code_inactive(self):

        self.log_user()

        old_title = 'RhodeCode'

        old_realm = 'RhodeCode authentication'

        new_ga_code = ''

        response = self.app.post(url('admin_setting', setting_id='global'),

                                     params=dict(

                                                 _method='put',

                                                 rhodecode_title=old_title,

                                                 rhodecode_realm=old_realm,

                                                 rhodecode_ga_code=new_ga_code

                                                 ))

        self.assertEqual(RhodeCodeSetting

                        .get_app_settings()['rhodecode_ga_code'], new_ga_code)

        response = response.follow()

        self.assertFalse("""_gaq.push(['_setAccount', '%s']);""" % new_ga_code

                         in response.body)

    def test_title_change(self):

        self.log_user()

        old_title = 'RhodeCode'

        new_title = old_title + '_changed'

        old_realm = 'RhodeCode authentication'

        for new_title in ['Changed', 'Żółwik', old_title]:

            response = self.app.post(url('admin_setting', setting_id='global'),

                                         params=dict(

                                                     _method='put',

                                                     rhodecode_title=new_title,

                                                     rhodecode_realm=old_realm,

                                                     rhodecode_ga_code=''

                                                     ))

            self.checkSessionFlash(response, 'Updated application settings')

            self.assertEqual(RhodeCodeSetting

        response = self.app.post(url('user', id=1), params=dict(_method='put'))

    def test_delete(self):

        self.log_user()

        username = 'newtestuserdeleteme'

        password = 'test12'

        name = 'name'

        lastname = 'lastname'

        email = 'todeletemail@mail.com'

        response = self.app.post(url('users'), {'username': username,

                                               'password': password,

                                               'password_confirmation': password,

                                               'firstname': name,

                                               'active': True,

                                               'lastname': lastname,

                                               'email': email})

        response = response.follow()

        new_user = self.Session.query(User)\

            .filter(User.username == username).one()

        response = self.app.delete(url('user', id=new_user.user_id))

    def test_delete_browser_fakeout(self):

        response = self.app.post(url('user', id=1),

                                 params=dict(_method='delete'))

    def test_show(self):

        response = self.app.get(url('user', id=1))

    def test_show_as_xml(self):

        response = self.app.get(url('formatted_user', id=1, format='xml'))

    def test_edit(self):

        self.log_user()

        user = User.get_by_username(TEST_USER_ADMIN_LOGIN)

        response = self.app.get(url('edit_user', id=user.user_id))

    def test_add_perm_create_repo(self):

        self.log_user()

        perm_none = Permission.get_by_key('hg.create.none')

        perm_create = Permission.get_by_key('hg.create.repository')

        user = UserModel().create_or_update(username='dummy', password='qwe',

                                            email='dummy', firstname='a',

                                            lastname='b')