self.checkSessionFlash(response,

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

                               % (urllib.quote(repo_name), repo_name_unicode))

        # test if the repo was created in the database

        new_repo = Session().query(Repository)\

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

        self.assertEqual(new_repo.repo_name, repo_name_unicode)

        self.assertEqual(new_repo.description, description_unicode)

        # test if the repository is visible in the list ?

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

        response.mustcontain(repo_name)

        response.mustcontain(self.REPO_TYPE)

        # test if the repository was created on filesystem

        try:

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

        except vcs.exceptions.VCSError:

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

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

        self.checkSessionFlash(response, 'Deleted repository %s' % (repo_name_unicode))

        response.follow()

        #check if repo was deleted from db

        deleted_repo = Session().query(Repository)\

            .filter(Repository.repo_name == repo_name_unicode).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=self.REPO),

                                 params=dict(_method='delete', _authentication_token=self.authentication_token()))

    def test_show(self):

        self.log_user()

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

    def test_edit(self):

        response = self.app.get(url('edit_repo', repo_name=self.REPO))

    def test_set_private_flag_sets_default_to_none(self):

        self.log_user()

        #initially repository perm should be read

        perm = _get_permission_for_user(user='default', repo=self.REPO)

        self.assertTrue(len(perm), 1)

        self.assertEqual(perm[0].permission.permission_name, 'repository.read')

        self.assertEqual(Repository.get_by_repo_name(self.REPO).private, False)

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

                        fixture._get_repo_create_params(repo_private=1,

                                                repo_name=self.REPO,

                                                repo_type=self.REPO_TYPE,

                                                user=TEST_USER_ADMIN_LOGIN,

                                                _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               msg='Repository %s updated successfully' % (self.REPO))

        self.assertEqual(Repository.get_by_repo_name(self.REPO).private, True)

        #now the repo default permission should be None

        perm = _get_permission_for_user(user='default', repo=self.REPO)

        self.assertTrue(len(perm), 1)

        self.assertEqual(perm[0].permission.permission_name, 'repository.none')

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=self.REPO,

                                                repo_type=self.REPO_TYPE,

                                                user=TEST_USER_ADMIN_LOGIN,

                                                _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               msg='Repository %s updated successfully' % (self.REPO))

        self.assertEqual(Repository.get_by_repo_name(self.REPO).private, False)

        #we turn off private now the repo default permission should stay None

        perm = _get_permission_for_user(user='default', repo=self.REPO)

        self.assertTrue(len(perm), 1)

        self.assertEqual(perm[0].permission.permission_name, 'repository.none')

        #update this permission back

        perm[0].permission = Permission.get_by_key('repository.read')

        Session().add(perm[0])

        Session().commit()

    def test_set_repo_fork_has_no_self_id(self):

        self.log_user()

        repo = Repository.get_by_repo_name(self.REPO)

        response = self.app.get(url('edit_repo_advanced', repo_name=self.REPO))

        response.mustcontain(no=[opt])

    def test_set_fork_of_other_repo(self):

        self.log_user()

        other_repo = 'other_%s' % self.REPO_TYPE

        fixture.create_repo(other_repo, repo_type=self.REPO_TYPE)

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(other_repo)

        response = self.app.put(url('edit_repo_advanced_fork', repo_name=self.REPO),

                                params=dict(id_fork_of=repo2.repo_id, _authentication_token=self.authentication_token()))

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(other_repo)

        self.checkSessionFlash(response,

            'Marked repo %s as fork of %s' % (repo.repo_name, repo2.repo_name))

        assert repo.fork == repo2

        response = response.follow()

        # check if given repo is selected

        opt = """<option value="%s" selected="selected">%s</option>""" % (

                    repo2.repo_id, repo2.repo_name)

        response.mustcontain(opt)

        fixture.destroy_repo(other_repo, forks='detach')

    def test_set_fork_of_other_type_repo(self):

        self.log_user()

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(self.OTHER_TYPE_REPO)

        response = self.app.put(url('edit_repo_advanced_fork', repo_name=self.REPO),

                                params=dict(id_fork_of=repo2.repo_id, _authentication_token=self.authentication_token()))

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(self.OTHER_TYPE_REPO)

        self.checkSessionFlash(response,

            'Cannot set repository as fork of repository with other type')

    def test_set_fork_of_none(self):

        self.log_user()

        ## mark it as None

        response = self.app.put(url('edit_repo_advanced_fork', repo_name=self.REPO),

                                params=dict(id_fork_of=None, _authentication_token=self.authentication_token()))

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(self.OTHER_TYPE_REPO)

        self.checkSessionFlash(response,

                               'Marked repo %s as fork of %s'

                               % (repo.repo_name, "Nothing"))

        assert repo.fork is None

    def test_set_fork_of_same_repo(self):

        self.log_user()

        repo = Repository.get_by_repo_name(self.REPO)

        response = self.app.put(url('edit_repo_advanced_fork', repo_name=self.REPO),

                                params=dict(id_fork_of=repo.repo_id, _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               'An error occurred during this operation')

    def test_create_on_top_level_without_permissions(self):

        usr = self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)

        # revoke

        user_model = UserModel()

        # disable fork and create on default user

        user_model.revoke_perm(User.DEFAULT_USER, 'hg.create.repository')

        user_model.grant_perm(User.DEFAULT_USER, 'hg.create.none')

        user_model.revoke_perm(User.DEFAULT_USER, 'hg.fork.repository')

        user_model.grant_perm(User.DEFAULT_USER, 'hg.fork.none')

        # disable on regular user

        user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.repository')

        user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.none')

        user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.repository')

        user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.none')

        Session().commit()

        user = User.get(usr['user_id'])

        repo_name = self.NEW_REPO+'no_perms'

        description = 'description for newly created repo'

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                _authentication_token=self.authentication_token()))

        response.mustcontain('no permission to create repository in root location')

        RepoModel().delete(repo_name)

        Session().commit()

    @mock.patch.object(RepoModel, '_create_filesystem_repo', error_function)

    def test_create_repo_when_filesystem_op_fails(self):

        self.log_user()

        repo_name = self.NEW_REPO

        description = 'description for newly created repo'