# -*- coding: utf-8 -*-

"""

 (c) 2015-2017 - Copyright Red Hat Inc

 Authors:

   Pierre-Yves Chibon <pingou@pingoured.fr></pingou@pingoured.fr>

"""

from __future__ import unicode_literals

__requires__ = ['SQLAlchemy >= 0.8']

import pkg_resources

import datetime

import unittest

import shutil

import sys

import tempfile

import os

import six

import json

import pygit2

from mock import patch, MagicMock

sys.path.insert(0, os.path.join(os.path.dirname(

    os.path.abspath(__file__)), '..'))

import pagure.lib

import tests

class PagureFlaskApptests(tests.Modeltests):

    """ Tests for flask app controller of pagure """

    def test_watch_list(self):

        ''' Test for watch list of a user '''

        user = tests.FakeUser(username='pingou')

        with tests.user_set(self.app.application, user):

            output = self.app.get('/', follow_redirects=True)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
You have no projects
',

                output_text)

            tests.create_projects(self.session)

            output = self.app.get('/', follow_redirects=True)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
My Projects
',

                output_text)

    def test_view_users(self):

        """ Test the view_users endpoint. """

        output = self.app.get('/users/?page=abc')

        self.assertEqual(output.status_code, 200)

        output_text = output.get_data(as_text=True)

        self.assertIn(

            '
\n      Users '

            '2', output_text)

        self.assertIn(

            '\n                  '

            '
pingou',

            output_text)

        self.assertIn(

            '\n                  '

            '
foo',

            output_text)

    @patch.dict('pagure.config.config', {'ITEM_PER_PAGE': 2})

    def test_view_user_repo_cnt(self):

        """ Test the repo counts on the view_user endpoint. """

        tests.create_projects(self.session)

        self.gitrepos = tests.create_projects_git(

            pagure.config.config['GIT_FOLDER'])

        output = self.app.get('/user/pingou')

        self.assertEqual(output.status_code, 200)

        output_text = output.get_data(as_text=True)

        self.assertIn(

            'Projects 3',

            output_text)

        self.assertIn(

            'page 1 of 2', output_text)

        self.assertEqual(output_text.count('class="repo_descripton"'), 2)

        self.assertIn(

            'Forks 0', output_text)

    def test_view_user(self):

        """ Test the view_user endpoint. """

        output = self.app.get('/user/pingou?repopage=abc&forkpage=def')

        self.assertEqual(output.status_code, 200)

        output_text = output.get_data(as_text=True)

        self.assertIn(

            'Projects 0',

            output_text)

        self.assertIn(

            'Forks 0',

            output_text)

        tests.create_projects(self.session)

        self.gitrepos = tests.create_projects_git(

            pagure.config.config['GIT_FOLDER'])

        output = self.app.get('/user/pingou?repopage=abc&forkpage=def')

        self.assertEqual(output.status_code, 200)

        output_text = output.get_data(as_text=True)

        self.assertIn(

            'Projects 3',

            output_text)

        self.assertIn(

            'Forks 0', output_text)

        self.assertNotIn(

            'page 1 of 2', output_text)

        self.assertEqual(output_text.count('class="repo_descripton"'), 3)

    @patch.dict('pagure.config.config', {'ENABLE_UI_NEW_PROJECTS': False})

    def test_new_project_when_turned_off_in_the_ui(self):

        """ Test the new_project endpoint when new project creation is

        not allowed in the UI of this pagure instance. """

        user = tests.FakeUser(username='foo')

        with tests.user_set(self.app.application, user):

            output = self.app.get('/new/')

            self.assertEqual(output.status_code, 404)

            data = {

                'description': 'Project #1',

                'name': 'project-1',

            }

            output = self.app.post('/new/', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 404)

    @patch.dict('pagure.config.config', {'ENABLE_UI_NEW_PROJECTS': False})

    def test_new_project_button_when_turned_off_in_the_ui_no_project(self):

        """ Test the index endpoint when new project creation is

        not allowed in the UI of this pagure instance. """

        user = tests.FakeUser(username='foo')

        with tests.user_set(self.app.application, user):

            output = self.app.get('/', follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
My Projects
',

                output_text)

            # master template

            self.assertNotIn(

                '

                output_text)

            # index_auth template

            self.assertNotIn(

                'title="Create New Project" aria-hidden="true">',

                output_text)

    @patch.dict('pagure.config.config', {'ENABLE_UI_NEW_PROJECTS': False})

    def test_new_project_button_when_turned_off_in_the_ui_w_project(self):

        """ Test the index endpoint when new project creation is

        not allowed in the UI of this pagure instance. """

        tests.create_projects(self.session)

        user = tests.FakeUser(username='pingou')

        with tests.user_set(self.app.application, user):

            output = self.app.get('/', follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
My Projects
',

                output_text)

            # master template

            self.assertNotIn(

                '

                output_text)

            # index_auth template

            self.assertNotIn(

                'title="Create New Project" aria-hidden="true">',

                output_text)

    def test_new_project_when_turned_off(self):

        """ Test the new_project endpoint when new project creation is

        not allowed in the pagure instance. """

        #turn the project creation off

        pagure.config.config['ENABLE_NEW_PROJECTS'] = False

        # Before

        projects = pagure.lib.search_projects(self.session)

        self.assertEqual(len(projects), 0)

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'project-1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'tickets', 'project-1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'docs', 'project-1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'requests', 'project-1.git')))

        user = tests.FakeUser()

        with tests.user_set(self.app.application, user):

            output = self.app.get('/new/')

            self.assertEqual(output.status_code, 404)

            #just get the csrf token

            pagure.config.config['ENABLE_NEW_PROJECTS'] = True

            output = self.app.get('/new/')

            pagure.config.config['ENABLE_NEW_PROJECTS'] = False

            csrf_token = output.get_data(as_text=True).split(

                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

            data = {

                'description': 'Project #1',

                'name': 'project-1',

            }

        user.username = 'foo'

        with tests.user_set(self.app.application, user):

            data['csrf_token'] =  csrf_token

            output = self.app.post('/new/', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 404)

        #After

        projects = pagure.lib.search_projects(self.session)

        self.assertEqual(len(projects), 0)

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'project-1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'tickets', 'project-1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'docs', 'project-1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'requests', 'project-1.git')))

        pagure.config.config['ENABLE_NEW_PROJECTS'] = True

    def test_new_project(self):

        """ Test the new_project endpoint. """

        # Before

        projects = pagure.lib.search_projects(self.session)

        self.assertEqual(len(projects), 0)

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'project#1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'tickets', 'project#1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'docs', 'project#1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'requests', 'project#1.git')))

        user = tests.FakeUser()

        with tests.user_set(self.app.application, user):

            output = self.app.get('/new/')

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                'Create new Project', output_text)

            csrf_token = output_text.split(

                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

            data = {

                'description': 'Project #1',

            }

            output = self.app.post('/new/', data=data)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                'Create new Project', output_text)

            self.assertIn(

                '<small>\n            This field is required. \n'</small>

                '          ', output_text)

            data['name'] = 'project-1'

            output = self.app.post('/new/', data=data)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn('Create new Project', output_text)

            self.assertNotIn(

                '<small>\n            This field is required. \n'</small>

                '          ', output_text)

            data['csrf_token'] =  csrf_token

            output = self.app.post('/new/', data=data)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn('Create new Project', output_text)

            self.assertIn(

                'No user '

                '"username" found',

                output_text)

        user.username = 'foo'

        with tests.user_set(self.app.application, user):

            data['csrf_token'] = csrf_token

            output = self.app.post('/new/', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
\nProject #1',

                output_text)

            self.assertIn('
This repo is brand new!
',

                          output_text)

            self.assertIn(

                '<title>Overview - project-1 - Pagure</title>', output_text)

        # After

        projects = pagure.lib.search_projects(self.session)

        self.assertEqual(len(projects), 1)

        self.assertTrue(os.path.exists(

            os.path.join(self.path, 'repos', 'project-1.git')))

        self.assertTrue(os.path.exists(

            os.path.join(self.path, 'repos', 'tickets', 'project-1.git')))

        self.assertTrue(os.path.exists(

            os.path.join(self.path, 'repos', 'docs', 'project-1.git')))

        self.assertTrue(os.path.exists(

            os.path.join(self.path, 'repos', 'requests', 'project-1.git')))

    @patch.dict('pagure.config.config', {'PROJECT_NAME_REGEX': '^1[a-z]*$'})

    def test_new_project_diff_regex(self):

        """ Test the new_project endpoint with a different regex. """

        # Before

        projects = pagure.lib.search_projects(self.session)

        self.assertEqual(len(projects), 0)

        user = tests.FakeUser(username='foo')

        with tests.user_set(self.app.application, user):

            output = self.app.get('/new/')

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                'Create new Project', output_text)

            csrf_token = self.get_csrf(output=output)

            data = {

                'description': 'Project #1',

                'name': 'project-1',

                'csrf_token':  csrf_token,

            }

            output = self.app.post('/new/', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '<title>New project - Pagure</title>', output_text)

            self.assertIn(

                'Create new Project', output_text)

            self.assertIn(

                '<small>\n            Invalid input. \n'</small>

                '          ', output_text)

    @patch.dict('pagure.config.config', {'PRIVATE_PROJECTS': True})

    def test_new_project_private(self):

        """ Test the new_project endpoint for a private project. """

        # Before

        projects = pagure.lib.search_projects(self.session)

        self.assertEqual(len(projects), 0)

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'foo', 'project#1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'tickets', 'foo', 'project#1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'docs', 'foo', 'project#1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'requests', 'foo', 'project#1.git')))

        user = tests.FakeUser()

        with tests.user_set(self.app.application, user):

            output = self.app.get('/new/')

            self.assertEqual(output.status_code, 200)

            self.assertIn(

                'Create new Project', output.get_data(as_text=True))

            csrf_token = self.get_csrf(output=output)

            data = {

                'description': 'Project #1',

                'private': True,

            }

            output = self.app.post('/new/', data=data)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                'Create new Project', output_text)

            self.assertIn(

                '<small>\n            This field is required. \n'</small>

                '          ', output_text)

            data['name'] = 'project-1'

            output = self.app.post('/new/', data=data)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn('Create new Project', output_text)

            self.assertNotIn(

                '<small>\n            This field is required. \n'</small>

                '          ', output_text)

            data['csrf_token'] =  csrf_token

            output = self.app.post('/new/', data=data)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn('Create new Project', output_text)

            self.assertIn(

                'No user '

                '"username" found',

                output_text)

        user.username = 'foo'

        with tests.user_set(self.app.application, user):

            data['csrf_token'] =  csrf_token

            output = self.app.post('/new/', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
\nProject #1',

                output_text)

            self.assertIn('
This repo is brand new!
',

                          output_text)

            self.assertIn(

                '<title>Overview - foo/project-1 - Pagure</title>', output_text)

        # After

        projects = pagure.lib.search_projects(self.session)

        self.assertEqual(len(projects), 0)

        projects = pagure.lib.search_projects(self.session, private=True)

        self.assertEqual(len(projects), 1)

        self.assertTrue(os.path.exists(

            os.path.join(self.path, 'repos', 'foo', 'project-1.git')))

        self.assertTrue(os.path.exists(

            os.path.join(self.path, 'repos', 'tickets', 'foo', 'project-1.git')))

        self.assertTrue(os.path.exists(

            os.path.join(self.path, 'repos', 'docs', 'foo', 'project-1.git')))

        self.assertTrue(os.path.exists(

            os.path.join(self.path, 'repos', 'requests', 'foo', 'project-1.git')))

    def test_non_ascii_new_project(self):

        """ Test the new_project endpoint with a non-ascii project. """

        # Before

        projects = pagure.lib.search_projects(self.session)

        self.assertEqual(len(projects), 0)

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'project-1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'tickets', 'project-1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'docs', 'project-1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'requests', 'project-1.git')))

        user = tests.FakeUser()

        user.username = 'foo'

        with tests.user_set(self.app.application, user):

            output = self.app.get('/new/')

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                'Create new Project', output_text)

            csrf_token = output_text.split(

                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

            data = {

                'description': 'Prõjéctö #1',

                'name': 'project-1',

                'csrf_token':  csrf_token,

                'create_readme': True,

            }

            output = self.app.post('/new/', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
\nPrõjéctö #1',

                output_text)

            self.assertIn(

                '''<section class="readme"></section>

              
project-1

Prõjéctö #1

            ''',

            output_text)

            data = {

                'description': 'Мой первый суперский репозиторий',

                'name': 'project-2',

                'csrf_token':  csrf_token,

                'create_readme': True,

            }

            output = self.app.post('/new/', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
\nМой первый суперский репозиторий',

                output_text)

            self.assertIn(

                '''<section class="readme"></section>

              
project-2

Мой первый суперский репозиторий

            ''',

            output_text)

        # After

        projects = pagure.lib.search_projects(self.session)

        self.assertEqual(len(projects), 2)

        for project in ['project-1', 'project-2']:

            self.assertTrue(os.path.exists(

                os.path.join(self.path, 'repos', '%s.git' % project)))

            self.assertTrue(os.path.exists(

                os.path.join(self.path, 'repos', 'tickets', '%s.git' % project)))

            self.assertTrue(os.path.exists(

                os.path.join(self.path, 'repos', 'docs', '%s.git' % project)))

            self.assertTrue(os.path.exists(

                os.path.join(self.path, 'repos', 'requests', '%s.git' % project)))

    @patch('pygit2.init_repository', wraps=pygit2.init_repository)

    def test_new_project_with_template(self, pygit2init):

        """ Test the new_project endpoint for a new project with a template set.

        """

        # Before

        projects = pagure.lib.search_projects(self.session)

        self.assertEqual(len(projects), 0)

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'project-1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'tickets', 'project-1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'docs', 'project-1.git')))

        self.assertFalse(os.path.exists(

            os.path.join(self.path, 'repos', 'requests', 'project-1.git')))

        user = tests.FakeUser()

        user.username = 'foo'

        with tests.user_set(self.app.application, user):

            output = self.app.get('/new/')

            self.assertEqual(output.status_code, 200)

            self.assertIn(

                'Create new Project', output.get_data(as_text=True))

            csrf_token = self.get_csrf(output=output)

            data = {

                'description': 'test',

                'name': 'project-1',

                'csrf_token':  csrf_token,

                'create_readme': True,

            }

            output = self.app.post('/new/', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            self.assertIn(

                '
\ntest',

                output.get_data(as_text=True))

            self.assertEqual(pygit2init.call_count, 4)

            pygit2init.assert_any_call(

                '%s/repos/project-1.git' % self.path,

                bare=True, template_path=None)

            path = os.path.join(self.path, 'repos', 'project-1.git')

            with patch.dict(

                    'pagure.config.config',

                    {'PROJECT_TEMPLATE_PATH': path}):

                data = {

                    'description': 'test2',

                    'name': 'project-2',

                    'csrf_token':  csrf_token,

                    'create_readme': True,

                }

                output = self.app.post('/new/', data=data, follow_redirects=True)

                self.assertEqual(output.status_code, 200)

                self.assertIn(

                    '
\ntest2',

                    output.get_data(as_text=True))

            self.assertEqual(pygit2init.call_count, 8)

            pygit2init.assert_any_call(

                '%s/repos/project-2.git' % self.path,

                bare=True,

                template_path='%s/repos/project-1.git' % self.path)

        # After

        projects = pagure.lib.search_projects(self.session)

        self.assertEqual(len(projects), 2)

        for project in ['project-1', 'project-2']:

            self.assertTrue(os.path.exists(

                os.path.join(self.path, 'repos', '%s.git' % project)))

            self.assertTrue(os.path.exists(

                os.path.join(self.path, 'repos', 'tickets', '%s.git' % project)))

            self.assertTrue(os.path.exists(

                os.path.join(self.path, 'repos', 'docs', '%s.git' % project)))

            self.assertTrue(os.path.exists(

                os.path.join(self.path, 'repos', 'requests', '%s.git' % project)))

    @patch.dict('pagure.config.config', {'CASE_SENSITIVE': True})

    def test_new_project_case_sensitive(self):

        tests.create_projects(self.session)

        tests.create_projects_git(os.path.join(self.path, 'repos'), bare=True)

        output = self.app.get('/test')

        self.assertEqual(output.status_code, 200)

        output = self.app.get('/TEST')

        self.assertEqual(output.status_code, 404)

        user = tests.FakeUser()

        user.username = 'foo'

        with tests.user_set(self.app.application, user):

            output = self.app.get('/new/')

            self.assertEqual(output.status_code, 200)

            csrf_token = self.get_csrf(output=output)

            data = {

                'description': 'TEST',

                'name': 'TEST',

                'csrf_token':  csrf_token,

                'create_readme': True,

            }

            self.app.post('/new/', data=data, follow_redirects=True)

            output = self.app.get('/TEST')

            self.assertEqual(output.status_code, 200)

    @patch('pagure.ui.app.admin_session_timedout')

    def test_user_settings(self, ast):

        """ Test the user_settings endpoint. """

        ast.return_value = False

        self.test_new_project()

        user = tests.FakeUser()

        with tests.user_set(self.app.application, user):

            output = self.app.get('/settings/')

            self.assertEqual(output.status_code, 404)

            self.assertIn('
Page not found (404)
', output.get_data(as_text=True))

        user.username = 'foo'

        with tests.user_set(self.app.application, user):

            output = self.app.get('/settings/')

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '<title>foo\'s settings - Pagure</title>', output_text)

            if self.get_wtforms_version() >= (2, 2):

                self.assertIn(

                    '

                    'id="ssh_key" name="ssh_key" required>',

                    output_text)

            else:

                 self.assertIn(

                    '

                    'id="ssh_key" name="ssh_key">', output_text)

            csrf_token = self.get_csrf(output=output)

            data = {

                'ssh_key': 'blah'

            }

            output = self.app.post('/settings/', data=data)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '<title>foo\'s settings - Pagure</title>', output_text)

            data['csrf_token'] =  csrf_token

            output = self.app.post(

                '/settings/', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn('Invalid SSH keys', output_text)

            self.assertIn(

                '<title>foo\'s settings - Pagure</title>', output_text)

            self.assertIn('>blah', output_text)

            csrf_token = output_text.split(

                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

            data = {

                'ssh_key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDUkub32fZnNI'

                           '1zJYs43vhhx3c6IcYo4yzhw1gQ37BLhrrNeS6x8l5PKX4J8ZP5'

                           '1XhViPaLbeOpl94Vm5VSCbLy0xtY9KwLhMkbKj7g6vvfxLm2sT'

                           'Osb15j4jzIkUYYgIE7cHhZMCLWR6UA1c1HEzo6mewMDsvpQ9wk'

                           'cDnAuXjK3Q==',

                'csrf_token': csrf_token

            }

            output = self.app.post(

                '/settings/', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn('Public ssh key updated', output_text)

            self.assertIn(

                '<title>foo\'s settings - Pagure</title>', output_text)

            if self.get_wtforms_version() >= (2, 2):

                self.assertIn(

                    '

                    'id="ssh_key" name="ssh_key" required>ssh-rsa AAAA',

                    output_text)

            else:

                 self.assertIn(

                    '

                    'id="ssh_key" name="ssh_key">ssh-rsa AAAA', output_text)

            ast.return_value = True

            output = self.app.get('/settings/')

            self.assertEqual(output.status_code, 302)

    @patch.dict('pagure.config.config', {'LOCAL_SSH_KEY': False})

    @patch('pagure.ui.app.admin_session_timedout')

    def test_user_settings_no_local_ssh_key_ui(self, ast):

        """ Test the ssh key field doesn't show when pagure is not managing

        the ssh keys. """

        ast.return_value = False

        self.test_new_project()

        user = tests.FakeUser(username = 'foo')

        with tests.user_set(self.app.application, user):

            output = self.app.get('/settings/')

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '<title>foo\'s settings - Pagure</title>', output_text)

            self.assertNotIn(

                '

                output_text)

    @patch.dict('pagure.config.config', {'LOCAL_SSH_KEY': False})

    @patch('pagure.ui.app.admin_session_timedout')

    def test_user_settings_no_local_ssh_key(self, ast):

        """ Test the user_settings endpoint when pagure is not managing the

        ssh keys. """

        ast.return_value = False

        self.test_new_project()

        user = tests.FakeUser(username = 'foo')

        with tests.user_set(self.app.application, user):

            output = self.app.get('/settings/')

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '<title>foo\'s settings - Pagure</title>', output_text)

            self.assertNotIn(

                '

                output_text)

            # Before

            user = pagure.lib.get_user(self.session, 'foo')

            self.assertIsNone(user.public_ssh_key)

            csrf_token = self.get_csrf(output=output)

            data = {

                'ssh_key': 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDUkub32fZnNI'

                           '1zJYs43vhhx3c6IcYo4yzhw1gQ37BLhrrNeS6x8l5PKX4J8ZP5'

                           '1XhViPaLbeOpl94Vm5VSCbLy0xtY9KwLhMkbKj7g6vvfxLm2sT'

                           'Osb15j4jzIkUYYgIE7cHhZMCLWR6UA1c1HEzo6mewMDsvpQ9wk'

                           'cDnAuXjK3Q==',

                'csrf_token': csrf_token

            }

            output = self.app.post(

                '/settings/', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertNotIn('Public ssh key updated', output_text)

            self.assertIn(

                '<title>foo\'s settings - Pagure</title>', output_text)

            self.assertNotIn(

                '

                output_text)

            # After

            user = pagure.lib.get_user(self.session, 'foo')

            self.assertIsNone(user.public_ssh_key)

    def patched_commit_exists(user, namespace, repo, githash):

        ''' Patched version of pagure.pfmarkdown._commit_exists to enforce

        returning true on some given hash without having us actually check

        the git repos.

        '''

        if githash in ['9364354', '9364354a', '9364354a4555ba17aa60f0dc844d70b74eb1aecd']:

            return True

        else:

            return False

    @patch(

        'pagure.pfmarkdown._commit_exists',

        MagicMock(side_effect=patched_commit_exists))

    def test_patched_markdown_preview(self):

        """ Test the markdown_preview endpoint. """

        data = {

            'content': 'test\n----\n\n * 1\n * item 2'

        }

        # CSRF missing

        output = self.app.post('/markdown/', data=data)

        self.assertEqual(output.status_code, 400)

        user = tests.FakeUser()

        user.username = 'foo'

        with tests.user_set(self.app.application, user):

            output = self.app.get('/settings/')

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '<title>foo\'s settings - Pagure</title>', output_text)

            if self.get_wtforms_version() >= (2, 2):

                self.assertIn(

                    '

                    'id="ssh_key" name="ssh_key" required>',

                    output_text)

            else:

                 self.assertIn(

                    '

                    'id="ssh_key" name="ssh_key">', output_text)

            csrf_token = self.get_csrf(output=output)

        # With CSRF

        data['csrf_token'] = csrf_token

        output = self.app.post('/markdown/', data=data)

        self.assertEqual(output.status_code, 200)

        exp = """
test

1

item 2

"""

        self.assertEqual(output.get_data(as_text=True), exp)

        tests.create_projects(self.session)

        texts = [

            'pingou committed on test#9364354a4555ba17aa60f0dc844d70b74eb1aecd',

            'Cf commit 936435',  # 6 chars - not long enough

            'Cf commit 9364354',  # 7 chars - long enough

            'Cf commit 9364354a',  # 8 chars - still long enough

            'Cf commit 9364354a4555ba17aa60f0dc844d70b74eb1aecd',  # 40 chars

        ]

        expected = [

            # 'pingou committed on test#9364354a4555ba17aa60f0dc844d70b74eb1aecd',

            '
pingou committed on 

            'title="Commit 9364354a4555ba17aa60f0dc844d70b74eb1aecd"'

            '>test#9364354a4555ba17aa60f0dc844d70b74eb1aecd
',

            # 'Cf commit 936435',

            '
Cf commit 936435
',

            # 'Cf commit 9364354',

            #'
Cf commit 9364354
',

            '
Cf commit 

            'title="Commit 9364354">9364354
',

            # 'Cf commit 9364354a',

            '
Cf commit 

            'title="Commit 9364354a">9364354
',

            # 'Cf commit 9364354a4555ba17aa60f0dc844d70b74eb1aecd',

            '
Cf commit 

            'title="Commit 9364354a4555ba17aa60f0dc844d70b74eb1aecd"'

            '>9364354
',

        ]

        with self.app.application.app_context():

            for idx, text in enumerate(texts):

                data = {

                    'content': text,

                    'csrf_token': csrf_token,

                }

                output = self.app.post('/markdown/?repo=test', data=data)

                self.assertEqual(output.status_code, 200)

                self.assertEqual(expected[idx], output.get_data(as_text=True))