def test_comaintain_package(self, login_func):
        """ Test the comaintain_package function. """
        login_func.return_value=None

        create_package_acl(self.session)

        user = FakeFasUser()
        with user_set(pkgdb.APP, user):
            output = self.app.get(
                '/acl/guake/comaintain/', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">ACLs updated</li>' in output.data)

            output = self.app.get(
                '/acl/random/comaintain/', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="error">No package found by this name</li>'
                in output.data)

        user = FakeFasUser()
        user.groups = ['gitr2spec']
        with user_set(pkgdb.APP, user):
            output = self.app.get(
                '/acl/guake/comaintain/', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">You must be a packager</li>'
                in output.data)
Example #2
0
    def test_index_filled(self):
        """ Test the index function. """
        self.setup_db()
        output = self.app.get('/')
        self.assertEqual(output.status_code, 200)
        self.assertTrue('<h2>Elections' in output.data)
        self.assertTrue('<h4><strong>Open elections</strong></h4>' in output.data)
        self.assertTrue('<strong>Upcoming elections</strong></h4>' in output.data)
        self.assertTrue('<a href="/login">Log In</a>' in output.data)

        user = FakeUser([], username='******')
        with user_set(fedora_elections.APP, user):
            output = self.app.get('/')
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<h2>Elections' in output.data)
            self.assertTrue('<h4><strong>Open elections</strong></h4>' in output.data)
            self.assertTrue('<strong>Upcoming elections</strong></h4>' in output.data)
            self.assertTrue('<a class="btn btn-sm btn-primary m-l-2" href="/vote/' in output.data)
            self.assertTrue(
                '<a class="dropdown-item" href="/logout">log out</a>' in output.data)
            self.assertEqual(output.data.count('Vote now!'), 4)

        user = FakeUser([], username='******')
        with user_set(fedora_elections.APP, user):
            output = self.app.get('/')
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<h2>Elections' in output.data)
            self.assertTrue('<h4><strong>Open elections</strong></h4>' in output.data)
            self.assertTrue('<strong>Upcoming elections</strong></h4>' in output.data)
            self.assertTrue(
                '<a class="dropdown-item" href="/logout">log out</a>' in output.data)
    def test_new_request_pull(self, send_email):
        """ Test the new_request_pull endpoint when the git repo has no
        master branch.
        """
        send_email.return_value = True

        tests.create_projects(self.session)
        # Non-existant git repo
        output = self.app.get('/test/diff/master..feature')
        # (used to be 302 but seeing a diff is allowed even logged out)
        self.assertEqual(output.status_code, 404)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/test/diff/master..feature')
            self.assertEqual(output.status_code, 404)

        self.set_up_git_repo()

        output = self.app.get('/test/diff/master..feature')
        # (used to be 302 but seeing a diff is allowed even logged out)
        self.assertEqual(output.status_code, 400)
        self.assertIn(
            '<p>Branch master could not be found in the target repo</p>',
            output.data)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/test/diff/master..feature')
            self.assertEqual(output.status_code, 400)
            self.assertIn(
                '<p>Branch master could not be found in the target repo</p>',
                output.data)
    def test_admin(self, login_func):
        """ Test the admin function. """
        login_func.return_value = None

        user = tests.FakeFasUser()
        with tests.user_set(mirrormanager2.app.APP, user):
            output = self.app.get('/admin/')
            self.assertEqual(output.status_code, 200)
            data = output.get_data(as_text=True)
            self.assertTrue('<title>Home - Admin</title>' in data)
            self.assertFalse(
                '<a href="/admin/archview/">Arch</a>' in data)
            self.assertFalse(
                '<a href="/admin/categoryview/">Category</a>' in data)

        user = tests.FakeFasUserAdmin()
        with tests.user_set(mirrormanager2.app.APP, user):
            output = self.app.get('/admin/')
            self.assertEqual(output.status_code, 200)
            data = output.get_data(as_text=True)
            self.assertTrue('<title>Home - Admin</title>' in data)
            self.assertTrue(re.search(
                '<a href="/admin/arch(view)?/">Arch</a>', data))
            self.assertTrue(re.search(
                '<a href="/admin/category(view)?/">Category</a>', data))
    def test_vote_irc(self):
        """ Test the vote_irc function - the preview part. """
        output = self.app.get(
            '/vote/test_election', follow_redirects=True)
        self.assertEqual(output.status_code, 200)
        self.assertTrue(
            '<title>OpenID transaction in progress</title>' in output.data
            or 'discoveryfailure' in output.data)

        self.setup_db()

        user = FakeUser(['packager'], username='******')
        with user_set(fedora_elections.APP, user):
            output = self.app.get(
                '/vote/test_election7', follow_redirects=True)
            self.assertTrue(
                'class="message">You have already voted in the election!</'
                in output.data)

        user = FakeUser(['packager'], username='******')
        with user_set(fedora_elections.APP, user):
            output = self.app.get(
                '/vote/test_election7')
            self.assertTrue(
                '<h2>test election 7 shortdesc</h2>' in output.data)
            self.assertTrue(
                '<input type="hidden" name="action" value="preview" />'
                in output.data)

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

            # Invalid vote: No candidate
            data = {
                'action': 'preview',
            }

            output = self.app.post('/vote/test_election7', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<h2>test election 7 shortdesc</h2>' in output.data)

            # Valid input
            data = {
                'Kevin': -1,
                'Toshio': '0',
                'action': 'preview',
                'csrf_token': csrf_token,
            }

            output = self.app.post('/vote/test_election7', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<h2>test election 7 shortdesc</h2>' in output.data)
            self.assertTrue(
                '<input type="hidden" name="action" value="submit" />'
                in output.data)
            self.assertTrue(
                '<li class="message">Please confirm your vote!</li>'
                in output.data)
    def test_new_request_pull(self, send_email):
        """ Test the new_request_pull endpoint when the git repo has no
        master branch.
        """
        send_email.return_value = True

        tests.create_projects(self.session)
        # Non-existant git repo
        output = self.app.get('/test/diff/master..maxamilion/feature')
        # (used to be 302 but seeing a diff is allowed even logged out)
        self.assertEqual(output.status_code, 404)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/test/diff/master..maxamilion/feature')
            self.assertEqual(output.status_code, 404)

        self.set_up_git_repo()

        output = self.app.get('/test/diff/master..maxamilion/feature')
        # (used to be 302 but seeing a diff is allowed even logged out)
        self.assertEqual(output.status_code, 200)
        self.assertEqual(
            output.data.count('<span class="commitdate" title='), 1)
        self.assertIn('<h5>.gitignore', output.data)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/test/diff/master..maxamilion/feature')
            self.assertEqual(output.status_code, 200)
            self.assertEqual(
                output.data.count('<span class="commitdate" title='), 1)
            self.assertIn('<h5>.gitignore', output.data)
    def test_new_request_pull(self, send_email):
        """ Test the new_request_pull endpoint when the git repo has no
        master branch.
        """
        send_email.return_value = True

        tests.create_projects(self.session)
        # Non-existant git repo
        output = self.app.get('/test/diff/master..maxamilion/feature')
        self.assertEqual(output.status_code, 302)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/test/diff/master..maxamilion/feature')
            self.assertEqual(output.status_code, 404)

        self.set_up_git_repo()

        output = self.app.get('/test/diff/master..maxamilion/feature')
        self.assertEqual(output.status_code, 302)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/test/diff/master..maxamilion/feature')
            self.assertEqual(output.status_code, 200)
            self.assertEqual(
                output.data.count('<td class="commitid">'), 1)
            self.assertIn('<h3>.gitignore</h3>', output.data)
Example #8
0
    def test_dropcommit_package(self, login_func, mock_func):
        """ Test the dropcommit_package function. """
        login_func.return_value = None

        create_package_acl(self.session)

        user = FakeFasUser()
        mock_func.return_value = ['pingou', 'ralph', 'kevin']

        with user_set(pkgdb2.APP, user):
            output = self.app.get(
                '/acl/guake/dropcommit/', follow_redirects=True)
            self.assertEqual(output.status_code, 405)

        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/guake/')
            csrf_token = output.data.split(
                'name="csrf_token" type="hidden" value="')[1].split('">')[0]
            data = {'csrf_token': csrf_token}

            output = self.app.post(
                '/acl/guake/dropcommit/',
                data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">ACLs updated</li>' in output.data)

            output = self.app.post(
                '/acl/random/dropcommit/',
                data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="error">No package found by this name</li>'
                in output.data)
Example #9
0
    def test_admin_index(self):
        """ Test the admin_index endpoint. """

        output = self.app.get('/admin')
        self.assertEqual(output.status_code, 302)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.post('/admin', follow_redirects=True)
            self.assertEqual(output.status_code, 404)
            self.assertIn(
                '</button>\n                      Access restricted',
                 output.data)

        user.username = '******'
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/admin', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      Access restricted',
                 output.data)

        user = tests.FakeUser(
            username='******',
            groups=pagure.APP.config['ADMIN_GROUP'])
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/admin', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<h2>Admin section</h2>' in output.data)
            self.assertTrue('Re-generate gitolite ACLs file' in output.data)
            self.assertTrue(
                'Re-generate user ssh key files' in output.data)
Example #10
0
    def test_index_filled(self):
        """ Test the index function. """
        self.setup_db()
        output = self.app.get('/')
        self.assertEqual(output.status_code, 200)
        self.assertTrue('<title>Fedora elections</title>' in output.data)
        self.assertTrue('<h3>Current elections</h3>' in output.data)
        self.assertTrue('<h3>Next 1 elections</h3>' in output.data)
        self.assertTrue('<h3>Last 2 elections</h3>' in output.data)
        self.assertTrue('<a href="/login">login</a>' in output.data)

        user = FakeUser([], username='******')
        with user_set(fedora_elections.APP, user):
            output = self.app.get('/')
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<title>Fedora elections</title>' in output.data)
            self.assertTrue('<h3>Current elections</h3>' in output.data)
            self.assertTrue('<h3>Next 1 elections</h3>' in output.data)
            self.assertTrue('<h3>Last 2 elections</h3>' in output.data)
            self.assertTrue('<a href="/vote/' in output.data)
            self.assertTrue(
                '<span class="text">logged in as </span>' in output.data)
            self.assertEqual(output.data.count('Vote now!'), 4)

        user = FakeUser([], username='******')
        with user_set(fedora_elections.APP, user):
            output = self.app.get('/')
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<title>Fedora elections</title>' in output.data)
            self.assertTrue('<h3>Current elections</h3>' in output.data)
            self.assertTrue('<h3>Next 1 elections</h3>' in output.data)
            self.assertTrue('<h3>Last 2 elections</h3>' in output.data)
            self.assertTrue(
                '<span class="text">logged in as </span>' in output.data)
            self.assertEqual(output.data.count('Vote now!'), 0)
    def test_view_plugin_page(self):
        """ Test the view_plugin_page endpoint. """

        output = self.app.get('/foo/settings/Mail')
        self.assertEqual(output.status_code, 302)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/foo/settings/Mail')
            self.assertEqual(output.status_code, 404)

            tests.create_projects(self.session)
            tests.create_projects_git(tests.HERE)

            output = self.app.get('/test/settings/Mail')
            self.assertEqual(output.status_code, 403)

        user.username = '******'
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/test/settings/Mail')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<form action="/test/settings/Mail" method="post">',
                output.data)
            self.assertIn(
                '<td><label for="mail_to">Mail to</label></td>',
                output.data)

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

            data = {
                'active': True,
                'mail_to': '*****@*****.**',
                'csrf_token': csrf_token,
            }

            output = self.app.post(
                '/test/settings/Mail', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<section class="settings">\n  <h3>Settings for test</h3>',
                output.data)
            self.assertIn(
                '</button>\n                      Hook Mail activated', output.data)

            data = {
                'mail_to': '',
                'csrf_token': csrf_token,
            }

            output = self.app.post(
                '/test/settings/Mail', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<section class="settings">\n  <h3>Settings for test</h3>',
                output.data)
            self.assertIn(
                '</button>\n                      Hook Mail inactived', output.data)
    def test_repo_stargazers(self):
        """ Test the repo_stargazers endpoint of pagure.ui.repo """

        # make pingou star the project
        # first create pingou
        user = tests.FakeUser()
        user.username = "******"
        with tests.user_set(self.app.application, user):
            csrf_token = self.get_csrf()
            data = {"csrf_token": csrf_token}

            output = self.app.post(
                "/test/star/1", data=data, follow_redirects=True
            )
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                "You starred this project", output.get_data(as_text=True)
            )
            self._check_star_count(data=data, stars=1)

        # now, test if pingou's name comes in repo stargazers
        output = self.app.get("/test/stargazers/")
        self.assertIn(
            "<title>Stargazers of test  - Pagure</title>",
            output.get_data(as_text=True),
        )
        self.assertIn(
            '<a class="font-weight-bold" href="/user/pingou">pingou</a>',
            output.get_data(as_text=True),
        )

        # make pingou unstar the project
        user = tests.FakeUser()
        user.username = "******"
        with tests.user_set(self.app.application, user):
            csrf_token = self.get_csrf()
            data = {"csrf_token": csrf_token}

            output = self.app.post(
                "/test/star/0", data=data, follow_redirects=True
            )
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                "You unstarred this project", output.get_data(as_text=True)
            )
            self._check_star_count(data=data, stars=0)

        # now, test if pingou's name comes in repo stargazers
        # it shouldn't because, he just unstarred
        output = self.app.get("/test/stargazers/")
        self.assertIn(
            "<title>Stargazers of test  - Pagure</title>",
            output.get_data(as_text=True),
        )
        self.assertNotIn(
            '<a class="font-weight-bold" href="/user/pingou">pingou</a>',
            output.get_data(as_text=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(tests.HERE, "project#1.git")))
        self.assertFalse(os.path.exists(os.path.join(tests.HERE, "tickets", "project#1.git")))
        self.assertFalse(os.path.exists(os.path.join(tests.HERE, "docs", "project#1.git")))
        self.assertFalse(os.path.exists(os.path.join(tests.HERE, "requests", "project#1.git")))

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get("/new/")
            self.assertEqual(output.status_code, 200)
            self.assertIn("<strong>Create new Project</strong>", output.data)

            csrf_token = output.data.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)
            self.assertIn("<strong>Create new Project</strong>", output.data)
            self.assertIn(
                "<small>\n                      This field is required." "&nbsp;\n                    </small>",
                output.data,
            )

            data["name"] = "project-1"
            output = self.app.post("/new/", data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn("<strong>Create new Project</strong>", output.data)
            self.assertNotIn(
                "<small>\n                      This field is required." "&nbsp;\n                    </small>",
                output.data,
            )

            data["csrf_token"] = csrf_token
            output = self.app.post("/new/", data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn("<strong>Create new Project</strong>", output.data)
            self.assertIn("</button>\n                      No user &#34;username&#34; found", output.data)

        user.username = "******"
        with tests.user_set(pagure.APP, user):
            data["csrf_token"] = csrf_token
            output = self.app.post("/new/", data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue("<p>Project #1</p>" in output.data)
            self.assertIn("</button>\n                      Project &#34;project-1&#34; created", output.data)

        # After
        projects = pagure.lib.search_projects(self.session)
        self.assertEqual(len(projects), 1)
        self.assertTrue(os.path.exists(os.path.join(tests.HERE, "project-1.git")))
        self.assertTrue(os.path.exists(os.path.join(tests.HERE, "tickets", "project-1.git")))
        self.assertTrue(os.path.exists(os.path.join(tests.HERE, "docs", "project-1.git")))
        self.assertTrue(os.path.exists(os.path.join(tests.HERE, "requests", "project-1.git")))
Example #14
0
    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(pagure.APP, user):
            output = self.app.get('/settings/')
            self.assertEqual(output.status_code, 404)
            self.assertTrue('<h2>Page not found (404)</h2>' in output.data)

        user.username = '******'
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/settings/')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="card-header">\n          Basic Information\n'
                '      </div>', output.data)
            self.assertIn(
                '<textarea class="form-control" id="ssh_key" name="ssh_key">'
                '</textarea>', output.data)

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

            data = {
                'ssh_key': 'this is my ssh key',
            }

            output = self.app.post('/settings/', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="card-header">\n          Basic Information\n'
                '      </div>', output.data)
            self.assertIn(
                '<textarea class="form-control" id="ssh_key" name="ssh_key">'
                'this is my ssh key</textarea>', output.data)

            data['csrf_token'] =  csrf_token

            output = self.app.post(
                '/settings/', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '</button>\n                      Public ssh key updated'
                in output.data)
            self.assertIn(
                '<div class="card-header">\n          Basic Information\n'
                '      </div>', output.data)
            self.assertIn(
                '<textarea class="form-control" id="ssh_key" name="ssh_key">'
                'this is my ssh key</textarea>', output.data)

            ast.return_value = True
            output = self.app.get('/settings/')
            self.assertEqual(output.status_code, 302)
    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.APP.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(tests.HERE, 'project-1.git')))
        self.assertFalse(os.path.exists(
            os.path.join(tests.HERE, 'tickets', 'project-1.git')))
        self.assertFalse(os.path.exists(
            os.path.join(tests.HERE, 'docs', 'project-1.git')))
        self.assertFalse(os.path.exists(
            os.path.join(tests.HERE, 'requests', 'project-1.git')))

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/new/')
            self.assertEqual(output.status_code, 404)

            #just get the csrf token
            pagure.APP.config['ENABLE_NEW_PROJECTS'] = True
            output = self.app.get('/new/')
            pagure.APP.config['ENABLE_NEW_PROJECTS'] = False

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

            data = {
                'description': 'Project #1',
                'name': 'project-1',
            }

        user.username = '******'
        with tests.user_set(pagure.APP, 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(tests.HERE, 'project-1.git')))
        self.assertFalse(os.path.exists(
            os.path.join(tests.HERE, 'tickets', 'project-1.git')))
        self.assertFalse(os.path.exists(
            os.path.join(tests.HERE, 'docs', 'project-1.git')))
        self.assertFalse(os.path.exists(
            os.path.join(tests.HERE, 'requests', 'project-1.git')))

        pagure.APP.config['ENABLE_NEW_PROJECTS'] = True
Example #16
0
    def test_admin_new_release(self):
        """ Test the admin_new_release function. """
        user = None
        with user_set(app.APP, user):
            output = self.app.get('/admin/new', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<title>OpenID transaction in progress</title>'
                in output.data)

        user = FakeFasUser()
        user.groups = []
        user.cla_done = False
        with user_set(app.APP, user):
            output = self.app.get('/admin/new', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="error">You are not an admin</li>' in output.data)

        user = FakeFasUser()
        user.groups = []
        with user_set(app.APP, user):
            output = self.app.get('/admin/new', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="error">You are not an admin</li>' in output.data)

        user = FakeFasUser()
        user.groups.append('sysadmin-main')
        with user_set(app.APP, user):
            output = self.app.get('/admin/new')
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<title> New release' in output.data)
            self.assertTrue(
                "<label for=\"releasenum\">Release number <span "
                "class='error'>*</span></label>" in output.data)

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

            data = {
                'csrf_token': csrf_token,
                'releasenum': 20,
                'support': 'RELEASE',
            }

            output = self.app.post(
                '/admin/new', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">Release &#34;20&#34; added</li>'
                in output.data)
            self.assertTrue("<a href='/release/20'>" in output.data)
            self.assertTrue("<a href='/admin/20/edit'" in output.data)
Example #17
0
    def test_admin_generate_hook_token(self):
        """ Test the admin_generate_hook_token endpoint. """

        output = self.app.get('/admin/hook_token')
        self.assertEqual(output.status_code, 404)

        output = self.app.post('/admin/hook_token')
        self.assertEqual(output.status_code, 302)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.post('/admin/hook_token', follow_redirects=True)
            self.assertEqual(output.status_code, 404)
            self.assertIn(
                '</button>\n                      Access restricted',
                 output.data)

        user.username = '******'
        with tests.user_set(pagure.APP, user):
            output = self.app.post('/admin/hook_token', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      Access restricted',
                 output.data)

        user = tests.FakeUser(
            username='******',
            groups=pagure.APP.config['ADMIN_GROUP'])
        with tests.user_set(pagure.APP, user):
            output = self.app.post('/admin/hook_token', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<h2>Admin section</h2>' in output.data)
            self.assertTrue('Re-generate gitolite ACLs file' in output.data)
            self.assertTrue(
                'Re-generate user ssh key files' in output.data)
            self.assertTrue(
                'Re-generate hook-token for every projects' in output.data)

            csrf_token = output.data.split(
                'name="csrf_token" type="hidden" value="')[1].split('">')[0]
            data = {'csrf_token': csrf_token}

            output = self.app.post(
                '/admin/hook_token', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<h2>Admin section</h2>' in output.data)
            self.assertTrue('Re-generate gitolite ACLs file' in output.data)
            self.assertTrue(
                'Re-generate user ssh key files' in output.data)
            self.assertTrue(
                'Re-generate hook-token for every projects' in output.data)
            self.assertTrue(
                '</button>\n                      Hook token all re-generated'
                in output.data)
Example #18
0
    def test_admin_generate_acl(self, wga):
        """ Test the admin_generate_acl endpoint. """
        wga.return_value = True

        output = self.app.get('/admin/gitolite')
        self.assertEqual(output.status_code, 404)

        output = self.app.post('/admin/gitolite')
        self.assertEqual(output.status_code, 302)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.post('/admin/gitolite', follow_redirects=True)
            self.assertEqual(output.status_code, 404)
            self.assertIn(
                '</button>\n                      Access restricted',
                 output.data)

        user.username = '******'
        with tests.user_set(pagure.APP, user):
            output = self.app.post('/admin/gitolite', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      Access restricted',
                 output.data)

        user = tests.FakeUser(
            username='******',
            groups=pagure.APP.config['ADMIN_GROUP'])
        with tests.user_set(pagure.APP, user):
            output = self.app.post('/admin/gitolite', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<h2>Admin section</h2>' in output.data)
            self.assertTrue('Re-generate gitolite ACLs file' in output.data)
            self.assertTrue(
                'Re-generate user ssh key files' in output.data)
            self.assertFalse(
                '<li class="message">Gitolite ACLs updated</li>'
                in output.data)

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

            data = {'csrf_token': csrf_token}
            output = self.app.post(
                '/admin/gitolite', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<h2>Admin section</h2>' in output.data)
            self.assertTrue('Re-generate gitolite ACLs file' in output.data)
            self.assertTrue(
                'Re-generate user ssh key files' in output.data)
            self.assertTrue(
                '</button>\n                      Gitolite ACLs updated'
                in output.data)
    def test_set_default_email(self, ast, send_email):
        """ Test the set_default_email endpoint. """
        send_email.return_value = True
        ast.return_value = False
        self.test_new_project()

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.post("/settings/email/default")
            self.assertEqual(output.status_code, 404)
            self.assertTrue("<h2>Page not found (404)</h2>" in output.data)

        user.username = "******"
        with tests.user_set(pagure.APP, user):
            output = self.app.get("/settings/")
            self.assertEqual(output.status_code, 200)
            self.assertIn('<div class="card-header">\n          Basic Information\n' "      </div>", output.data)
            self.assertIn('<textarea class="form-control" id="ssh_key" name="ssh_key">' "</textarea>", output.data)

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

            data = {"email": "*****@*****.**"}

            output = self.app.post("/settings/email/default", data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn('<div class="card-header">\n          Basic Information\n' "      </div>", output.data)
            self.assertEqual(output.data.count("*****@*****.**"), 4)

            # Set invalid default email
            data = {"csrf_token": csrf_token, "email": "*****@*****.**"}

            output = self.app.post("/settings/email/default", data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn('<div class="card-header">\n          Basic Information\n' "      </div>", output.data)
            self.assertEqual(output.data.count("*****@*****.**"), 4)
            self.assertIn(
                "</button>\n                      You do not have the " "email: [email protected], nothing to set",
                output.data,
            )

            # Set default email
            data = {"csrf_token": csrf_token, "email": "*****@*****.**"}

            output = self.app.post("/settings/email/default", data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn('<div class="card-header">\n          Basic Information\n' "      </div>", output.data)
            self.assertEqual(output.data.count("*****@*****.**"), 4)
            self.assertIn("</button>\n                      Default email set to: " "*****@*****.**", output.data)

            ast.return_value = True
            output = self.app.post("/settings/email/default", data=data)
            self.assertEqual(output.status_code, 302)
    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(pagure.APP, user):
            output = self.app.get('/settings/')
            self.assertEqual(output.status_code, 404)
            self.assertTrue('<h2>Page not found (404)</h2>' in output.data)

        user.username = '******'
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/settings/')
            self.assertEqual(output.status_code, 200)
            self.assertTrue("<h2>foo's settings</h2>" in output.data)
            self.assertTrue(
                '<textarea id="ssh_key" name="ssh_key"></textarea>'
                in output.data)

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

            data = {
                'ssh_key': 'this is my ssh key',
            }

            output = self.app.post('/settings/', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue("<h2>foo's settings</h2>" in output.data)
            self.assertTrue(
                '<textarea id="ssh_key" name="ssh_key">this is my ssh key'
                '</textarea>' in output.data)

            data['csrf_token'] =  csrf_token

            output = self.app.post(
                '/settings/', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">Public ssh key updated</li>'
                in output.data)
            self.assertTrue(
                '<section class="project_list" id="repos">' in output.data)
            self.assertTrue(
                '<section class="project_list" id="forks">' in output.data)

            ast.return_value = True
            output = self.app.get('/settings/')
            self.assertEqual(output.status_code, 302)
    def test_package_request_new(self, login_func, mock_func):
        """ Test the package_request_new function. """
        login_func.return_value = None
        mock_func.return_value = ['pingou', 'toshio']
        create_package_acl(self.session)

        data = {
            'pkgname': 'gnome-terminal',
            'summary': 'terminal for GNOME',
            'description': 'desc',
            'review_url': 'https://bz.rh.c/123',
            'status': 'Approved',
            'critpath': False,
            'poc': 'pingou',
            'upstream_url': 'http://gnome.org',
            'branches': 'master',
            'namespace': 'rpms',
        }

        user = FakeFasUser()

        user.username = '******'
        data['branches'] = 'epel7'
        with user_set(pkgdb2.APP, user):

            # Branch EPEL7 does not exist
            output = self.app.post(
                '/request/package/', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<td class="errors">&#39;epel7&#39; is not a valid choice'
                in output.data)

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

        data['csrf_token'] = csrf_token
        data['branches'] = 'master'

        # All good
        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/request/package/',
                follow_redirects=True, data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">user: pingou request package: '
                'gnome-terminal on branch master</li>' in output.data)
    def test_collection_status(self, login_func):
        """ Test the api_collection_status function.  """
        login_func.return_value = None

        # Redirect as you are not admin
        user = FakeFasUser()

        with user_set(pkgdb2.APP, user):
            output = self.app.post("/api/collection/f18/status/")
            self.assertEqual(output.status_code, 302)

        user = FakeFasUserAdmin()

        with user_set(pkgdb2.APP, user):
            output = self.app.post("/api/collection/f18/status/")
            self.assertEqual(output.status_code, 500)
            data = json.loads(output.data)
            self.assertEqual(sorted(data), ["error", "error_detail", "output"])
            self.assertEqual(data["error"], "Invalid input submitted")

            self.assertEqual(data["output"], "notok")

            self.assertEqual(
                sorted(data["error_detail"]), ["branch: This field is required.", "clt_status: Not a valid choice"]
            )

        data = {"branch": "f18", "clt_status": "EOL"}
        with user_set(pkgdb2.APP, user):
            output = self.app.post("/api/collection/f19/status/", data=data)
            self.assertEqual(output.status_code, 500)
            data = json.loads(output.data)
            self.assertEqual(data, {"output": "notok", "error": "You're trying to update the wrong collection"})

        data = {"branch": "f18", "clt_status": "EOL"}
        with user_set(pkgdb2.APP, user):
            output = self.app.post("/api/collection/f18/status", data=data)
            self.assertEqual(output.status_code, 500)
            data = json.loads(output.data)
            self.assertEqual(data, {"output": "notok", "error": 'Could not find collection "f18"'})

        create_collection(self.session)

        data = {"branch": "f18", "clt_status": "EOL"}
        with user_set(pkgdb2.APP, user):
            output = self.app.post("/api/collection/f18/status", data=data)
            self.assertEqual(output.status_code, 200)
            data = json.loads(output.data)
            self.assertEqual(data, {"output": "ok", "messages": ['Collection updated from "Active" to "EOL"']})
    def test_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 = "******"
        with tests.user_set(pagure.APP, user):
            output = self.app.get("/settings/")
            self.assertEqual(output.status_code, 200)
            self.assertIn('<div class="card-header">\n          Basic Information\n' "      </div>", output.data)
            self.assertIn('<textarea class="form-control" id="ssh_key" name="ssh_key">' "</textarea>", output.data)

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

        # With CSRF
        data["csrf_token"] = csrf_token
        output = self.app.post("/markdown/", data=data)
        self.assertEqual(output.status_code, 200)
        exp = """<h2>test</h2>
<ul>
<li>1</li>
<li>item 2</li>
</ul>"""
        self.assertEqual(output.data, exp)
    def test_index(self):
        """ Test the index endpoint. """

        output = self.app.get("/")
        self.assertEqual(output.status_code, 200)
        self.assertIn('<h2 class=" m-b-1">All Projects ' '<span class="label label-default">0</span></h2>', output.data)

        tests.create_projects(self.session)

        output = self.app.get("/?page=abc")
        self.assertEqual(output.status_code, 200)
        self.assertIn('<h2 class=" m-b-1">All Projects ' '<span class="label label-default">2</span></h2>', output.data)

        # Add a 3rd project with a long description
        item = pagure.lib.model.Project(
            user_id=2,  # foo
            name="test3",
            description="test project #3 with a very long description",
            hook_token="aaabbbeee",
        )
        self.session.add(item)
        self.session.commit()

        user = tests.FakeUser(username="******")
        with tests.user_set(pagure.APP, user):
            output = self.app.get("/?repopage=abc&forkpage=def")
            self.assertIn('Projects <span class="label label-default">1</span>', output.data)
            self.assertIn('Forks <span class="label label-default">0</span>', output.data)
            self.assertEqual(output.data.count("<p>No projects found</p>"), 1)
            self.assertEqual(output.data.count("<p>No group found</p>"), 1)
            self.assertEqual(output.data.count('<div class="card-header">'), 3)
    def test_index(self):
        """ Test the index endpoint. """

        output = self.app.get('/')
        self.assertEqual(output.status_code, 200)
        self.assertTrue('<h2>All Projects (0)</h2>' in output.data)

        tests.create_projects(self.session)

        output = self.app.get('/?page=abc')
        self.assertEqual(output.status_code, 200)
        self.assertTrue('<h2>All Projects (2)</h2>' in output.data)

        # Add a 3rd project with a long description
        item = pagure.lib.model.Project(
            user_id=2,  # foo
            name='test3',
            description='test project #3 with a very long description',
            hook_token='aaabbbeee',
        )
        self.session.add(item)
        self.session.commit()

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/?repopage=abc&forkpage=def')
            self.assertTrue(
                '<section class="project_list" id="repos">' in output.data)
            self.assertTrue('<h3>My Forks (0)</h3>' in output.data)
            self.assertTrue(
                '<section class="project_list" id="myforks">' in output.data)
            self.assertTrue('<h3>My Projects (0)</h3>' in output.data)
            self.assertTrue(
                '<section class="project_list" id="myrepos">' in output.data)
            self.assertTrue('<h3>All Projects (3)</h3>' in output.data)
    def test_milestones_without_dates(self, p_send_email, p_ugt):
        """ Test creating two milestones with no dates. """
        tests.create_projects(self.session)
        tests.create_projects_git(os.path.join(tests.HERE), bare=True)

        user = tests.FakeUser()
        user.username = '******'
        with tests.user_set(pagure.APP, user):
            # Get the CSRF token
            output = self.app.get('/test/settings')
            csrf_token = output.data.split(
                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

            data = {
                'milestones': ['v1.0', 'v2.0'],
                'milestone_dates': ['', ''],
                'csrf_token': csrf_token,
            }
            output = self.app.post(
                '/test/update/milestones', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            # Check the redirect
            self.assertIn(
                u'<title>Settings - test - Pagure</title>', output.data)
            self.assertIn(u'<h3>Settings for test</h3>', output.data)
            self.assertIn(u'Milestones updated', output.data)
            # Check the result of the action -- Milestones recorded
            repo = pagure.lib.get_project(self.session, 'test')
            self.assertEqual(repo.milestones, {u'v1.0': u'', u'v2.0': u''})
    def test_plugin_mail_activate_hook_no_doc(self):
        """ Test the pagure hook plugin endpoint when activating the hook
        on a pagure instance that de-activated the doc repos.
        """

        user = tests.FakeUser(username="******")
        with tests.user_set(self.app.application, user):
            csrf_token = self.get_csrf()

            # Activate hook
            data = {"csrf_token": csrf_token, "active": "y"}

            output = self.app.post(
                "/test/settings/Pagure", data=data, follow_redirects=True
            )
            output_text = output.get_data(as_text=True)
            self.assertIn("Hook Pagure activated", output_text)

            self.assertTrue(
                os.path.exists(
                    os.path.join(
                        self.path, "repos", "test.git", "hooks", "post-receive"
                    )
                )
            )
            self.assertFalse(
                os.path.exists(
                    os.path.join(
                        self.path, "docs", "test.git", "hooks", "post-receive"
                    )
                )
            )
    def test_issue_page_milestone_not_allactives(self):
        """ Test viewing tickets on a project having milestones, not all
        being active.
        """

        repo = pagure.lib.query.get_authorized_project(self.session, "test")

        milestones = {
            "1.0": {"date": None, "active": False},
            "2.0": {"date": "2018-01-01", "active": False},
            "3.0": {"date": "2025-01-01", "active": True},
            "4.0": {"date": "future", "active": True},
        }
        milestones_keys = ["1.0", "2.0", "3.0", "4.0"]
        repo.milestones = milestones
        repo.milestones_keys = milestones_keys
        self.session.add(repo)
        self.session.commit()

        user = tests.FakeUser(username="******")
        with tests.user_set(self.app.application, user):
            output = self.app.get("/test/issue/1")
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<select class="form-control c-select" id="milestone" name="milestone">'
                '<option selected value=""></option>'
                '<option value="3.0">3.0</option>'
                '<option value="4.0">4.0</option>'
                "</select>",
                output.get_data(as_text=True),
            )
    def test_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 = '******'
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/settings/')
            self.assertEqual(output.status_code, 200)
            self.assertTrue("<h2>foo's settings</h2>" in output.data)
            self.assertTrue(
                '<textarea id="ssh_key" name="ssh_key"></textarea>'
                in output.data)

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

        # With CSRF
        data['csrf_token'] = csrf_token
        output = self.app.post('/markdown/', data=data)
        self.assertEqual(output.status_code, 200)
        exp = """<h2>test</h2>
<ul>
<li>1</li>
<li>item 2</li>
</ul>"""
        self.assertEqual(output.data, exp)
    def test_plugin_mail_no_data(self):
        """ Test the pagure hook plugin endpoint when no data is sent. """

        user = tests.FakeUser(username="******")
        with tests.user_set(self.app.application, user):

            data = {}

            output = self.app.post("/test/settings/Pagure", data=data)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                "<title>Settings Pagure - test - Pagure</title>", output_text
            )
            self.assertIn(
                '<input class="form-check-input mt-2" id="active" name="active" '
                'type="checkbox" value="y">',
                output_text,
            )

            self.assertFalse(
                os.path.exists(
                    os.path.join(
                        self.path, "repos", "test.git", "hooks", "post-receive"
                    )
                )
            )
            self.assertFalse(
                os.path.exists(
                    os.path.join(
                        self.path, "docs", "test.git", "hooks", "post-receive"
                    )
                )
            )
    def test_group_delete(self):
        """ Test the group_delete endpoint. """
        output = self.app.post('/group/foo/delete')
        self.assertEqual(output.status_code, 302)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.post('/group/foo/delete', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<p>No groups have been created on this pagure instance '
                'yet</p>', output.data)
            self.assertIn(
                '<h2 class="m-b-1">\n'
                '    Groups <span class="label label-default">0</span>',
                output.data)

        self.test_add_group()

        with tests.user_set(pagure.APP, user):
            output = self.app.post('/group/foo/delete', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<h2 class="m-b-1">\n'
                '    Groups <span class="label label-default">1</span>',
                output.data)

            output = self.app.get('/new/')
            csrf_token = output.data.split(
                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

        user.username = '******'
        with tests.user_set(pagure.APP, user):

            data = {
                'csrf_token': csrf_token,
            }
            output = self.app.post(
                '/group/bar/delete', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      No group `bar` found',
                output.data)
            self.assertIn(
                '<h2 class="m-b-1">\n'
                '    Groups <span class="label label-default">1</span>',
                output.data)

            output = self.app.post(
                '/group/test_group/delete', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      You are not allowed to '
                'delete the group test_group', output.data)
            self.assertIn(
                '<h2 class="m-b-1">\n'
                '    Groups <span class="label label-default">1</span>',
                output.data)

        user.username = '******'
        with tests.user_set(pagure.APP, user):

            output = self.app.post(
                '/group/test_group/delete', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 404)

        user.username = '******'
        with tests.user_set(pagure.APP, user):

            output = self.app.post(
                '/group/test_group/delete', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      Group `test_group` has '
                'been deleted', output.data)
            self.assertIn(
                '<h2 class="m-b-1">\n'
                '    Groups <span class="label label-default">0</span>',
                output.data)
    def test_package_give(self, login_func, utils_module):
        """ Test the package_give function. """
        login_func.return_value = None
        create_package_acl(self.session)

        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/rpms/guake/give')
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<title> Give package | PkgDB </title>' in output.data)

            output = self.app.get('/package/rpms/guake/give/0')
            self.assertEqual(output.status_code, 200)
            self.assertFalse(
                '<title> Give package | PkgDB </title>' in output.data)
            self.assertTrue(
                '<h1>Give Point of Contact of package: guake</h1>'
                in output.data)
            self.assertTrue(
                '<input id="csrf_token" name="csrf_token"' in output.data)

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

            data = {
                'branches': '',
                'poc': '',
                'csrf_token': csrf_token,
            }

            output = self.app.post('/package/rpms/guake/give', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertEqual(
                output.data.count(
                    '<td class="errors">This field is required.</td>'
                ), 1)

        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/rpms/guake/give')
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<h1>Give Point of Contact of package: guake</h1>'
                in output.data)
            self.assertTrue(
                '<input id="csrf_token" name="csrf_token"' in output.data)

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

            data = {
                'branches': 'master',
                'poc': 'limb',
                'csrf_token': csrf_token,
            }

            output = self.app.post('/package/rpms/guake/give', data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                'class="error">User &#34;limb&#34; is not in the packager '
                'group</' in output.data)

        utils_module.get_packagers.return_value = ['spot']
        utils_module.log.return_value = ''

        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/rpms/guake/give')
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<h1>Give Point of Contact of package: guake</h1>'
                in output.data)
            self.assertTrue(
                '<input id="csrf_token" name="csrf_token"' in output.data)

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

            data = {
                'branches': 'master',
                'poc': 'spot',
                'csrf_token': csrf_token,
            }

            output = self.app.post('/package/rpms/guake/give', data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                'rpms/<span property="doap:name">guake</span>'
                in output.data)
            self.assertTrue('<a href="/packager/spot/">' in output.data)

        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/rpms/random/give')
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">No package of this name found.</li>'
                in output.data)

        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/rpms/guake/give')
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<h1>Give Point of Contact of package: guake</h1>'
                in output.data)
            self.assertTrue(
                '<input id="csrf_token" name="csrf_token"' in output.data)

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

            data = {
                'branches': 'master',
                'poc': 'spot',
                'csrf_token': csrf_token,
            }

            output = self.app.post('/package/rpms/guake/give', data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<td><select id="branches" multiple ''name="branches">'
                '</select></td>' in output.data)
    def test_group_user_delete(self):
        """ Test the group_user_delete endpoint. """
        output = self.app.post('/group/foo/bar/delete')
        self.assertEqual(output.status_code, 302)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.post(
                '/group/foo/bar/delete', follow_redirects=True)
            self.assertEqual(output.status_code, 404)

        self.test_add_group()

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.post(
                '/group/test_group/bar/delete', follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> &nbsp;'
                'Test Group', output.data)
            self.assertEqual(output.data.count('<a href="/user/'), 1)

            output = self.app.get('/new/')
            csrf_token = output.data.split(
                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

            data = {'csrf_token': csrf_token}

            output = self.app.post(
                '/group/test_group/bar/delete', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      No user `bar` found',
                output.data)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> &nbsp;'
                'Test Group', output.data)
            self.assertEqual(output.data.count('<a href="/user/'), 1)

            output = self.app.post(
                '/group/test_group/foo/delete', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      Could not find user '
                'username', output.data)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> &nbsp;'
                'Test Group', output.data)
            self.assertEqual(output.data.count('<a href="/user/'), 1)

        user.username = '******'
        with tests.user_set(pagure.APP, user):
            # User not in the group
            output = self.app.post(
                '/group/test_group/foo/delete', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      User `foo` could not be '
                'found in the group `test_group`', output.data)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> &nbsp;'
                'Test Group', output.data)
            self.assertEqual(output.data.count('<a href="/user/'), 1)

            # Cannot delete creator
            output = self.app.post(
                '/group/test_group/foo/delete', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      User `foo` could not be '
                'found in the group `test_group`', output.data)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> &nbsp;'
                'Test Group', output.data)
            self.assertEqual(output.data.count('<a href="/user/'), 1)

            # Add user foo
            data = {
                'user': '******',
                'csrf_token': csrf_token,
            }
            output = self.app.post('/group/test_group', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      User `foo` added to the '
                'group `test_group`.', output.data)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> &nbsp;'
                'Test Group', output.data)
            self.assertEqual(output.data.count('<a href="/user/'), 2)

            output = self.app.post(
                '/group/test_group/foo/delete', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      User `foo` removed from '
                'the group `test_group`', output.data)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> &nbsp;'
                'Test Group', output.data)
            self.assertEqual(output.data.count('<a href="/user/'), 1)
Example #34
0
    def test_new_project(self, ast):
        """ Test creating a new repo by default on repoSpanner works. """
        ast.return_value = False

        user = tests.FakeUser(username="******")
        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("<strong>Create new Project</strong>", output_text)

            data = {
                "name": "project-1",
                "description": "Project #1",
                "create_readme": "y",
                "csrf_token": self.get_csrf(),
            }

            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(
                '<div class="projectinfo my-3">\nProject #1', output_text
            )
            self.assertIn(
                "<title>Overview - project-1 - Pagure</title>", output_text
            )
            self.assertIn("Added the README", output_text)

            output = self.app.get("/project-1/settings")
            self.assertIn(
                "This repository is on repoSpanner region default",
                output.get_data(as_text=True),
            )

        with tests.user_set(
            self.app.application, tests.FakeUser(username="******")
        ):
            # Verify that for forking, Git auth status is ignored (hooks should not be run)
            self.set_auth_status(False)

            data = {"csrf_token": self.get_csrf()}

            output = self.app.post(
                "/do_fork/project-1", data=data, follow_redirects=True
            )
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                '<div class="projectinfo my-3">\nProject #1', output_text
            )
            self.assertIn(
                "<title>Overview - project-1 - Pagure</title>", output_text
            )
            self.assertIn("Added the README", output_text)
            self.assertIn(
                "/?next=http://localhost/fork/pingou/project-1", output_text
            )

            output = self.app.get("/fork/pingou/project-1/settings")
            self.assertIn(
                "This repository is on repoSpanner region default",
                output.get_data(as_text=True),
            )

        # Verify that only pseudo repos exist, and no on-disk repos got created
        repodirlist = os.listdir(os.path.join(self.path, "repos"))
        self.assertEqual(repodirlist, ["pseudo"])
    def test_package_request_branch(self, login_func, mock_func):
        """ Test the package_request_branch function. """
        login_func.return_value = None
        mock_func.get_packagers.return_value = ['pingou', 'toshio']
        create_package_acl(self.session)

        data = {
            'branches': ['epel7'],
        }

        user = FakeFasUser()
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/foobar/request_branch', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">No package of this name found.</li>'
                in output.data)

            output = self.app.post(
                '/package/rpms/guake/request_branch', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<td class="errors">&#39;epel7&#39; is not a valid choice '
                'for this field</td>' in output.data)

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

        data = {
            'branches': ['el6'],
            'csrf_token': csrf_token,
        }

        # Input correct but user is not allowed
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/request_branch/0',
                follow_redirects=True, data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="error">User &#34;kevin&#34; is not in the '
                'packager group</li>' in output.data)

        data = {
            'branches': ['el6'],
            'csrf_token': csrf_token,
        }

        # All good
        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/request_branch',
                follow_redirects=True, data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">Branch el6 requested for user pingou</'
                in output.data)

        # Check the request authenticated
        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/requests/1')
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<h1>Update request: 1</h1>' in output.data)
            self.assertTrue(
                'As current admin of the package  you have the possibility'
                in output.data)
            self.assertTrue(
                '<form action="/package/requests/1"' in output.data)

        # Check the request un-authenticated
        with user_set(pkgdb2.APP, None):
            output = self.app.get('/package/requests/1')
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<h1>Request: 1</h1>' in output.data)
            self.assertFalse(
                'As current admin of the package  you have the possibility'
                in output.data)
            self.assertFalse(
                '<form action="/package/requests/1"' in output.data)
    def test_upload_results_autotest(self):
        ''' Test the app.upload_results function for the autotest user. '''
        folder = os.path.dirname(os.path.abspath(__file__))
        filename = '3.log'
        full_path = os.path.join(folder, filename)

        user = None
        with user_set(app.APP, user):
            output = self.app.get('/upload/autotest')
            self.assertEqual(output.status_code, 405)
            self.assertTrue(
                '<title>405 Method Not Allowed</title>' in output.data)

            # Not logged in, /upload/ not allowed
            stream = open(full_path)
            data = {
                'test_result': stream,
                'username': '******',
            }
            output = self.app.post('/upload/', data=data)
            self.assertEqual(output.status_code, 302)
            self.assertTrue('<title>Redirecting...</title>' in output.data)

            # Missing the api_token field
            stream = open(full_path)
            data = {
                'test_result': stream,
                'username': '******',
            }
            output = self.app.post('/upload/autotest', data=data)
            self.assertEqual(output.status_code, 400)
            data = json.loads(output.data)
            exp = {
                "error": "Invalid request",
                "messages": {
                    "api_token": [
                        "This field is required."
                    ]
                }
            }
            self.assertEqual(data, exp)

            # Invalid api_token
            stream = open(full_path)
            data = {
                'test_result': stream,
                'username': '******',
                'api_token': 'foobar',
            }
            output = self.app.post('/upload/autotest', data=data)
            self.assertEqual(output.status_code, 401)
            data = json.loads(output.data)
            exp = {"error": "Invalid api_token provided"}
            self.assertEqual(data, exp)

            # Valid api_token
            app.APP.config['API_KEY'] = 'api token for the tests'
            stream = open(full_path)
            data = {
                'test_result': stream,
                'username': '******',
                'api_token': 'api token for the tests',
            }
            output = self.app.post('/upload/autotest', data=data)
            self.assertEqual(output.status_code, 200)
            data = json.loads(output.data)
            exp = {"message": "Upload successful!"}
            self.assertEqual(data, exp)

            # Second valid upload
            full_path = os.path.join(folder, '4.log')
            stream = open(full_path)
            data = {
                'test_result': stream,
                'username': '******',
                'api_token': 'api token for the tests',
            }
            output = self.app.post('/upload/autotest', data=data)
            self.assertEqual(output.status_code, 200)
            data = json.loads(output.data)
            exp = {"message": "Upload successful!"}
            self.assertEqual(data, exp)

            # Invalid file upload
            full_path = os.path.join(folder, 'invalid.log')
            stream = open(full_path)
            data = {
                'test_result': stream,
                'username': '******',
                'api_token': 'api token for the tests',
            }
            output = self.app.post('/upload/autotest', data=data)
            self.assertEqual(output.status_code, 400)
            data = json.loads(output.data)
            exp = {"error": "Invalid input file"}
            self.assertEqual(data, exp)
    def test_upload_results_anonymous(self):
        ''' Test the app.upload_results function for an anonymous user. '''
        folder = os.path.dirname(os.path.abspath(__file__))
        filename = '2.log'

        user = None
        with user_set(app.APP, user):
            output = self.app.get('/upload/')
            self.assertEqual(output.status_code, 302)
            self.assertTrue('<title>Redirecting...</title>' in output.data)

        user = None
        with user_set(app.APP, user):
            output = self.app.get('/upload/anonymous')
            self.assertEqual(output.status_code, 405)
            self.assertTrue(
                '<title>405 Method Not Allowed</title>' in output.data)

            full_path = os.path.join(folder, filename)
            stream = open(full_path)
            data = {
                'test_result': stream,
                'username': '******',
            }
            output = self.app.post('/upload/', data=data)
            self.assertEqual(output.status_code, 302)
            self.assertTrue('<title>Redirecting...</title>' in output.data)

            # Invalid request
            data = {
                'username': '******',
            }
            output = self.app.post('/upload/anonymous', data=data)
            self.assertEqual(output.status_code, 400)
            data = json.loads(output.data)
            exp = {
                "error": "Invalid request",
                "messages": {
                    "test_result": [
                        "This field is required."
                    ]
                }
            }
            self.assertEqual(data, exp)

            # Invalid username

            stream = open(full_path)
            data = {
                'test_result': stream,
                'username': '******',
            }
            output = self.app.post('/upload/anonymous', data=data)
            self.assertEqual(output.status_code, 401)
            data = json.loads(output.data)
            exp = {
                'error': 'The `kerneltest` username is reserved, you are '
                'not allowed to use it'
            }
            self.assertEqual(data, exp)

            # Valid and successful upload
            stream = open(full_path)
            data = {
                'test_result': stream,
                'username': '******',
            }
            output = self.app.post('/upload/anonymous', data=data)
            self.assertEqual(output.status_code, 200)
            data = json.loads(output.data)
            self.assertEqual(data, {'message': 'Upload successful!'})

            # Invalid file upload
            full_path = os.path.join(folder, 'invalid.log')
            stream = open(full_path)
            data = {
                'test_result': stream,
                'username': '******',
            }
            output = self.app.post('/upload/anonymous', data=data)
            self.assertEqual(output.status_code, 400)
            data = json.loads(output.data)
            exp = {"error": "Invalid input file"}
            self.assertEqual(data, exp)

            # Invalid mime type uploaded
            full_path = os.path.join(folder, 'denied.png')
            stream = open(full_path)
            data = {
                'test_result': stream,
                'username': '******',
            }
            output = self.app.post('/upload/anonymous', data=data)
            self.assertEqual(output.status_code, 400)
            data = json.loads(output.data)
            exp = {"error": "Invalid input file"}
            self.assertEqual(data, exp)
    def test_package_request_edit(self, login_func, mock_func):
        """ Test the package_request_edit function. """
        login_func.return_value = None
        mock_func.get_packagers.return_value = ['pingou', 'toshio']
        mock_func.log.return_value = 'foo bar'
        create_package_acl(self.session)

        data = {
            'branches': ['epel7'],
        }

        user = FakeFasUser()
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/requests/1', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">No action found with this identifier.</li>'
                in output.data)

            create_admin_actions(self.session)

            # User not allowed to view request
            output = self.app.post(
                '/package/requests/1', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">Only package adminitrators (`approveacls`)'
                ' and the requester can review pending branch requests</li>'
                in output.data)
            output = self.app.get(
                '/package/requests/2', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)

            self.assertIn('<h1>Update admin action: 2</h1>', output.data)
            self.assertIn(
                '<form action="/package/requests/2"\n    method="post">',
                output.data)
            self.assertIn(
                '<td><textarea id="message" name="message" placeholder='
                '"Required if the action is blocked or denied"></textarea>',
                output.data)

        # Before the edit
        user = FakeFasUser()
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/requests/1')
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<h1>Update request: 1</h1>' in output.data)
            self.assertTrue(
                '<option selected value="Pending">' in output.data)

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

            data = {
                'status': 'Awaiting Review',
                'csrf_token': csrf_token,
            }

            # User cannot approve their own request
            output = self.app.post(
                '/package/requests/1',
                follow_redirects=True, data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<td class="errors">Not a valid choice</td>' in output.data)

        data = {
            'status': 'Obsolete',
            'csrf_token': csrf_token,
        }

        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            # Admin cannot obsolete a request that is not their
            output = self.app.post(
                '/package/requests/1',
                follow_redirects=True, data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<td class="errors">Not a valid choice</td>' in output.data)

            data['status'] = 'Awaiting Review'
            # All good
            output = self.app.post(
                '/package/requests/1',
                follow_redirects=True, data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue('<li class="message">foo bar</li>'in output.data)
    def test_plugin_mail(self):
        """ Test the irc plugin on/off endpoint. """

        tests.create_projects(self.session)
        tests.create_projects_git(self.path)

        user = tests.FakeUser(username='******')
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/test/settings/IRC')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertTrue('<h3>IRC settings</h3>' in output.data)
            self.assertTrue(
                '<input id="active" name="active" type="checkbox" value="y">'
                in output.data)

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

            data = {}

            output = self.app.post('/test/settings/IRC', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertTrue('<h3>IRC settings</h3>' in output.data)
            self.assertTrue(
                '<input id="active" name="active" type="checkbox" value="y">'
                in output.data)

            self.assertFalse(os.path.exists(os.path.join(
                self.path, 'test.git', 'hooks', 'post-receive.irc')))

            data['csrf_token'] = csrf_token

            # With the git repo
            output = self.app.post(
                '/test/settings/IRC', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<section class="settings">\n  <h3>Settings for test</h3>',
                output.data)
            self.assertTrue(
                '</button>\n                      Hook IRC inactived' in output.data)

            output = self.app.get('/test/settings/IRC')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertTrue('<h3>IRC settings</h3>' in output.data)
            self.assertTrue(
                '<input id="active" name="active" type="checkbox" value="y">'
                in output.data)

            self.assertFalse(os.path.exists(os.path.join(
                self.path, 'test.git', 'hooks', 'post-receive.irc')))

            # Activate hook
            data = {
                'csrf_token': csrf_token,
                'active': 'y',
                'server': 'irc.freenode.net',
                'port': 6667,
                'room': '#fedora-apps',
            }

            output = self.app.post(
                '/test/settings/IRC', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<section class="settings">\n  <h3>Settings for test</h3>',
                output.data)
            self.assertTrue(
                '</button>\n                      Hook IRC activated' in output.data)

            output = self.app.get('/test/settings/IRC')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertTrue('<h3>IRC settings</h3>' in output.data)
            self.assertTrue(
                '<input checked id="active" name="active" type="checkbox" '
                'value="y">' in output.data)

            # TODO: Fix this
            #self.assertTrue(os.path.exists(os.path.join(
                #self.path, 'test.git', 'hooks', 'post-receive.irc')))

            # De-Activate hook
            data = {'csrf_token': csrf_token}
            output = self.app.post('/test/settings/IRC', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<section class="settings">\n  <h3>Settings for test</h3>',
                output.data)
            self.assertTrue(
                '</button>\n                      Hook IRC inactived' in output.data)

            output = self.app.get('/test/settings/IRC')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertTrue('<h3>IRC settings</h3>' in output.data)
            self.assertTrue(
                '<input id="active" name="active" type="checkbox" '
                'value="y">' in output.data)

            self.assertFalse(os.path.exists(os.path.join(
                self.path, 'test.git', 'hooks', 'post-receive.irc')))
Example #40
0
    def test_adopt_project(self, ast):
        """ Test adopting a project in repoSpanner works. """
        ast.return_value = False

        user = tests.FakeUser(username="******")
        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("<strong>Create new Project</strong>", output_text)

            data = {
                "name": "project-1",
                "description": "Project #1",
                "create_readme": "y",
                "csrf_token": self.get_csrf(),
            }

            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(
                '<div class="projectinfo my-3">\nProject #1', output_text
            )
            self.assertIn(
                "<title>Overview - project-1 - Pagure</title>", output_text
            )
            self.assertIn("Added the README", output_text)

            output = self.app.get("/project-1/settings")
            self.assertIn(
                "This repository is on repoSpanner region default",
                output.get_data(as_text=True),
            )

        # Delete the project instance so that the actual repo remains
        project = pagure.lib.query._get_project(self.session, "project-1")
        self.session.delete(project)
        self.session.commit()
        shutil.rmtree(os.path.join(self.path, "repos", "pseudo"))

        user = tests.FakeUser(username="******")
        with tests.user_set(self.app.application, user):
            output = self.app.get("/project-1/")
            self.assertEqual(output.status_code, 404)

            data = {
                "name": "project-1",
                "description": "Recreated project #1",
                "create_readme": "false",
                "csrf_token": self.get_csrf(),
            }
            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(
                "Repo pagure/main/project-1 already exists", output_text
            )

            data["ignore_existing_repos"] = "y"
            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(
                '<div class="projectinfo my-3">\nRecreated project #1',
                output_text,
            )
            self.assertIn(
                "<title>Overview - project-1 - Pagure</title>", output_text
            )
            self.assertIn("Added the README", output_text)
Example #41
0
    def test_hooks(self, ast):
        """ Test hook setting and running works. """
        ast.return_value = False
        pagure.cli.admin.session = self.session

        user = tests.FakeUser(username="******")
        with tests.user_set(self.app.application, user):
            data = {
                "name": "project-1",
                "description": "Project #1",
                "create_readme": "y",
                "csrf_token": self.get_csrf(),
            }

            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(
                '<div class="projectinfo my-3">\nProject #1', output_text
            )
            self.assertIn(
                "<title>Overview - project-1 - Pagure</title>", output_text
            )
            self.assertIn("Added the README", output_text)

            output = self.app.get("/project-1/settings")
            self.assertIn(
                "This repository is on repoSpanner region default",
                output.get_data(as_text=True),
            )

            # Check file before the commit:
            output = self.app.get("/project-1/raw/master/f/README.md")
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertEqual(output_text, "# project-1\n\nProject #1")

        with tests.user_set(self.app.application, user):
            # Set editing Denied
            self.set_auth_status(False)

            # Try to make an edit in the repo
            data = {
                "content": "foo\n bar\n  baz",
                "commit_title": "test commit",
                "commit_message": "Online commit",
                "email": "*****@*****.**",
                "branch": "master",
                "csrf_token": self.get_csrf(),
            }

            output = self.app.post(
                "/project-1/edit/master/f/README.md",
                data=data,
                follow_redirects=True,
            )
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn("Remote hook declined the push: ", output_text)
            self.assertIn(
                "Denied push for ref &#39;refs/heads/master&#39; for user &#39;foo&#39;",
                output_text,
            )

            # Check file after the commit:
            output = self.app.get("/project-1/raw/master/f/README.md")
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertEqual(output_text, "# project-1\n\nProject #1")

            # Set editing Allowed
            self.set_auth_status(True)

            # Try to make an edit in the repo
            data = {
                "content": "foo\n bar\n  baz",
                "commit_title": "test commit",
                "commit_message": "Online commit",
                "email": "*****@*****.**",
                "branch": "master",
                "csrf_token": self.get_csrf(),
            }

            output = self.app.post(
                "/project-1/edit/master/f/README.md",
                data=data,
                follow_redirects=True,
            )
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                "<title>Commits - project-1 - Pagure</title>", output_text
            )

            # Check file after the commit:
            output = self.app.get("/project-1/raw/master/f/README.md")
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertEqual(output_text, "foo\n bar\n  baz")
    def test_plugin_fedmsg(self):
        """ Test the fedmsg plugin on/off endpoint. """

        tests.create_projects(self.session)

        user = tests.FakeUser(username='******')
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/test/settings/Fedmsg')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertTrue('<h3>Fedmsg settings</h3>' in output.data)
            self.assertTrue(
                '<input id="active" name="active" type="checkbox" value="y">'
                in output.data)

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

            data = {}

            output = self.app.post('/test/settings/Fedmsg', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertTrue('<h3>Fedmsg settings</h3>' in output.data)
            self.assertTrue(
                '<input id="active" name="active" type="checkbox" value="y">'
                in output.data)

            self.assertFalse(
                os.path.exists(
                    os.path.join(tests.HERE, 'test.git', 'hooks',
                                 'post-receive.fedmsg')))

            data['csrf_token'] = csrf_token
            # No git found
            output = self.app.post('/test/settings/Fedmsg', data=data)
            self.assertEqual(output.status_code, 404)

            tests.create_projects_git(tests.HERE)

            # With the git repo
            output = self.app.post('/test/settings/Fedmsg',
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<section class="settings">\n  <h3>Settings for test</h3>',
                output.data)
            self.assertIn(
                '</button>\n                      Hook Fedmsg inactived',
                output.data)
            output = self.app.get('/test/settings/Fedmsg', data=data)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertIn('<h3>Fedmsg settings</h3>', output.data)
            self.assertIn(
                '<input id="active" name="active" type="checkbox" value="y">',
                output.data)

            self.assertFalse(
                os.path.exists(
                    os.path.join(tests.HERE, 'test.git', 'hooks',
                                 'post-receive.fedmsg')))

            # Activate hook
            data = {
                'csrf_token': csrf_token,
                'active': 'y',
            }

            output = self.app.post('/test/settings/Fedmsg',
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<section class="settings">\n  <h3>Settings for test</h3>',
                output.data)
            self.assertIn(
                '</button>\n                      Hook Fedmsg activated',
                output.data)
            output = self.app.get('/test/settings/Fedmsg', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertTrue('<h3>Fedmsg settings</h3>' in output.data)
            self.assertTrue(
                '<input checked id="active" name="active" type="checkbox" '
                'value="y">' in output.data)

            self.assertTrue(
                os.path.exists(
                    os.path.join(tests.HERE, 'test.git', 'hooks',
                                 'post-receive.fedmsg')))

            # De-Activate hook
            data = {'csrf_token': csrf_token}
            output = self.app.post('/test/settings/Fedmsg',
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<section class="settings">\n  <h3>Settings for test</h3>',
                output.data)
            self.assertIn(
                '</button>\n                      Hook Fedmsg inactived',
                output.data)
            output = self.app.get('/test/settings/Fedmsg', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertTrue('<h3>Fedmsg settings</h3>' in output.data)
            self.assertTrue('<input id="active" name="active" type="checkbox" '
                            'value="y">' in output.data)

            self.assertFalse(
                os.path.exists(
                    os.path.join(tests.HERE, 'test.git', 'hooks',
                                 'post-receive.fedmsg')))
    def test_plugin_pagure_ticket_activate(self):
        """ Test the pagure_ticket plugin on/off endpoint. """

        user = tests.FakeUser(username="******")
        with tests.user_set(self.app.application, user):
            # Activate hook
            data = {"csrf_token": self.csrf_token, "active": "y"}

            output = self.app.post(
                "/test/settings/Prevent creating new branches by git push",
                data=data,
                follow_redirects=True,
            )
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                "Project Settings</h5>\n",
                output_text,
            )
            self.assertIn(
                "Hook Prevent creating new branches by git push activated",
                output_text,
            )

            output = self.app.get(
                "/test/settings/Prevent creating new branches by git push")
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                "<title>Settings Prevent creating new branches by git push "
                "- test - Pagure</title>",
                output_text,
            )
            self.assertIn(
                '<input checked class="form-check-input mt-2" id="active" name="active" '
                'type="checkbox" value="y">',
                output_text,
            )

            # De-Activate hook
            data = {"csrf_token": self.csrf_token}
            output = self.app.post(
                "/test/settings/Prevent creating new branches by git push",
                data=data,
                follow_redirects=True,
            )
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                "Project Settings</h5>\n",
                output_text,
            )
            self.assertIn(
                "Hook Prevent creating new branches by git push deactivated",
                output_text,
            )

            output = self.app.get(
                "/test/settings/Prevent creating new branches by git push")
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                "<title>Settings Prevent creating new branches by git push "
                "- test - Pagure</title>",
                output_text,
            )
            self.assertIn(
                '<input class="form-check-input mt-2" id="active" name="active" '
                'type="checkbox" value="y">',
                output_text,
            )

            self.assertFalse(
                os.path.exists(
                    os.path.join(
                        self.path,
                        "repos",
                        "test.git",
                        "hooks",
                        "pre-receive.pagure_no_new_branches",
                    )))
    def test_delete_package(self, login_func, utils_module):
        """ Test the delete_package function. """
        login_func.return_value = None
        utils_module.get_packagers.return_value = ['pingou', 'toshio']
        create_package_acl(self.session)

        data = {}

        # User is not an admin
        user = FakeFasUser()
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/delete', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">You are not an administrator of pkgdb'
                '</li>' in output.data)

        # User is an admin but no csrf
        user = FakeFasUserAdmin()
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/delete', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="error">Invalid input</li>' in output.data)

            output = self.app.get('/package/rpms/guake/')
            csrf_token = output.data.split(
                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

        data = {
            'csrf_token': csrf_token,
        }

        # User is not an admin but csrf
        user = FakeFasUser()
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/delete', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">You are not an administrator of pkgdb'
                '</li>' in output.data)

            # Check before deleting
            output = self.app.get('/packages/')
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<p>5 packages found</p>' in output.data)

        # User is an admin with csrf
        user = FakeFasUserAdmin()
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/delete', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">Package guake deleted</li>'
                in output.data)
            self.assertTrue(
                '<p>4 packages found</p>' in output.data)

            output = self.app.post(
                '/package/rpms/random/delete', follow_redirects=True, data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">No package of this name found.</li>'
                in output.data)
    def test_package_timeline(self):
        """ Test the package_timeline function. """

        output = self.app.get('/package/rpms/guake/timeline')
        self.assertEqual(output.status_code, 200)
        self.assertTrue('</a> > Timeline' in output.data)
        self.assertTrue(
            'Restrict to packager: <input type="text" name="packager" />'
            in output.data)

        output = self.app.get(
            '/package/rpms/guake/timeline?page=abc&limit=def&from_date=ghi'
            '&package=test')
        self.assertEqual(output.status_code, 200)
        self.assertTrue('</a> > Timeline' in output.data)
        self.assertTrue(
            'Restrict to packager: <input type="text" name="packager" />'
            in output.data)
        self.assertTrue(
            'class="errors">Incorrect limit provided, using default</'
            in output.data)
        self.assertTrue(
            'class="errors">Incorrect from_date provided, using default</'
            in output.data)
        self.assertTrue(
            '<li class="errors">No package exists</li>' in output.data)

        output = self.app.get('/package/rpms/guake/timeline?from_date=2013-10-19')
        self.assertEqual(output.status_code, 200)
        self.assertTrue('</a> > Timeline' in output.data)
        self.assertTrue(
            'Restrict to packager: <input type="text" name="packager" />'
            in output.data)
        self.assertTrue(
            '<p class=\'error\'>No logs found in the database.</p>'
            in output.data)

        # Put some data in the database
        create_package_acl(self.session)
        guake_pkg = model.Package.by_name(self.session, 'rpms', 'guake')
        pkgdb2.lib.utils.log(
            self.session,
            guake_pkg,
            'acl.update',
            dict(
                agent='pingou',
                username='******',
                acl='commit',
                previous_status='Approved',
                status='Obsolete',
                package_name='guake',
                package_listing={
                    'collection': {'branchname': 'master'}
                },
            )
        )
        pkgdb2.lib.utils.log(
            self.session,
            guake_pkg,
            'acl.update',
            dict(
                agent='pingou',
                username='******',
                acl='approveacls',
                previous_status='Obsolete',
                status='Approved',
                package_name='guake',
                package_listing={
                    'collection': {'branchname': 'master'}
                },
            )
        )

        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/rpms/guake/timeline')
            self.assertEqual(output.status_code, 200)
            self.assertTrue('</a> > Timeline' in output.data)
            self.assertTrue(
                'Restrict to packager: <input type="text" name="packager" />'
                in output.data)
            self.assertTrue(
                'user: pingou set for pingou acl: commit of package: guake '
                'from: Approved to: Obsolete on branch: master'
                in output.data)
            self.assertTrue(
                'user: pingou set for pingou acl: approveacls of package: '
                'guake from: Obsolete to: Approved on branch: master'
                in output.data)
    def test_package_take(self, login_func, utils_module):
        """ Test the package_take function. """
        login_func.return_value = None
        utils_module.get_packagers.return_value = ['pingou', 'toshio']

        create_package_acl(self.session)

        data = {
            'branches': ['master'],
        }

        user = FakeFasUser()
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/take', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="error">No branches orphaned found</li>'
                in output.data)
            csrf_token = output.data.split(
                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

        data = {
            'branches': ['master'],
            'csrf_token': csrf_token,
        }

        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/orphan', follow_redirects=True, data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">You are no longer point of contact on '
                'branch: master</li>' in output.data)

        data = {
            'branches': ['foo'],
        }

        user = FakeFasUser()
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/take', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<td class="errors">&#39;foo&#39; is not a valid choice '
                'for this field</td>' in output.data)
            csrf_token = output.data.split(
                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

        data = {
            'branches': ['master'],
            'csrf_token': csrf_token,
        }

        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/rpms/guake/take')
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<title> Select branches | PkgDB </title>' in output.data)

            output = self.app.get('/package/rpms/guake/take/0')
            self.assertEqual(output.status_code, 200)
            self.assertFalse(
                '<title> Select branches | PkgDB </title>' in output.data)

            output = self.app.post(
                '/package/rpms/guake/take', follow_redirects=True, data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">You have taken the package guake on '
                'branch master</li>' in output.data)

        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/random/take', follow_redirects=True, data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">No package of this name found.</li>'
                in output.data)
Example #47
0
    def test_plugin_mail(self):
        """ Test the mail plugin on/off endpoint. """

        tests.create_projects(self.session)
        tests.create_projects_git(os.path.join(self.path, 'repos'))

        user = tests.FakeUser(username='******')
        with tests.user_set(self.app.application, user):
            output = self.app.get('/test/settings/Mail')
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn('<title>Settings Mail - test - Pagure</title>',
                          output_text)
            self.assertIn('<label for="mail_to">Mail to</label>', output_text)
            self.assertIn(
                '<input class="form-check-input mt-2" id="active" name="active" '
                'type="checkbox" value="y">', output_text)

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

            data = {}

            output = self.app.post('/test/settings/Mail', data=data)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn('<title>Settings Mail - test - Pagure</title>',
                          output_text)
            self.assertIn('<label for="mail_to">Mail to</label>', output_text)
            self.assertIn(
                '<input class="form-check-input mt-2" id="active" name="active" '
                'type="checkbox" value="y">', output_text)

            data['csrf_token'] = csrf_token

            # With the git repo
            output = self.app.post('/test/settings/Mail',
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                'Project Settings</h5>\n', output_text)
            self.assertIn('Hook Mail deactivated', output_text)

            output = self.app.get('/test/settings/Mail')
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn('<title>Settings Mail - test - Pagure</title>',
                          output_text)
            self.assertIn('<label for="mail_to">Mail to</label>', output_text)
            self.assertIn(
                '<input class="form-check-input mt-2" id="active" name="active" '
                'type="checkbox" value="y">', output_text)

            # Missing the required mail_to
            data = {'csrf_token': csrf_token, 'active': 'y'}

            output = self.app.post('/test/settings/Mail',
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn('<title>Settings Mail - test - Pagure</title>',
                          output_text)
            self.assertNotIn('Hook activated', output_text)
            if self.get_wtforms_version() >= (2, 2):
                self.assertIn(
                    '<div class="col-sm-10">\n        '
                    '<input class="form-control pl-0" id="mail_to" name="mail_to" '
                    'required type="text" value="">\n    </div>\n  </div>\n      '
                    '<div class="alert alert-danger">This field is required.</div>',
                    output_text)
            else:
                self.assertIn(
                    '<div class="col-sm-10">\n        '
                    '<input class="form-control pl-0" id="mail_to" name="mail_to" '
                    'type="text" value="">\n    </div>\n  </div>\n      '
                    '<div class="alert alert-danger">This field is required.</div>',
                    output_text)
            self.assertIn(
                '<input checked class="form-check-input mt-2" id="active" name="active" '
                'type="checkbox" value="y">', output_text)

            # Activate hook
            data = {
                'csrf_token': csrf_token,
                'active': 'y',
                'mail_to': 'foo@bar'
            }

            output = self.app.post('/test/settings/Mail',
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                'Project Settings</h5>\n', output_text)
            self.assertIn('Hook Mail activated', output_text)

            output = self.app.get('/test/settings/Mail')
            output_text = output.get_data(as_text=True)
            self.assertIn('<title>Settings Mail - test - Pagure</title>',
                          output_text)
            self.assertIn('<label for="mail_to">Mail to</label>', output_text)
            self.assertIn(
                '<input checked class="form-check-input mt-2" id="active" name="active" '
                'type="checkbox" value="y">', output_text)

            # De-Activate hook
            data = {'csrf_token': csrf_token}
            output = self.app.post('/test/settings/Mail',
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                'Project Settings</h5>\n', output_text)
            self.assertIn('Hook Mail deactivated', output_text)

            output = self.app.get('/test/settings/Mail')
            output_text = output.get_data(as_text=True)
            self.assertIn('<title>Settings Mail - test - Pagure</title>',
                          output_text)
            self.assertIn('<label for="mail_to">Mail to</label>', output_text)
            self.assertIn(
                '<input class="form-check-input mt-2" id="active" name="active" '
                'type="checkbox" value="y">', output_text)
    def test_add_group(self):
        """ Test the add_group endpoint. """
        output = self.app.get('/group/add')
        self.assertEqual(output.status_code, 302)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/group/add')
            self.assertEqual(output.status_code, 403)

        user.username = '******'
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/group/add')
            self.assertEqual(output.status_code, 200)
            self.assertIn('<strong>Create new group</strong>', output.data)
            self.assertNotIn(
                '<option value="admin">admin</option>', output.data)

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

            data = {
            }

            # Insufficient input
            output = self.app.post('/group/add', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn('<strong>Create new group</strong>', output.data)
            self.assertEqual(output.data.count(
                'This field is required.'), 3)

            data = {
                'group_name': 'test_group',
                'display_name': 'Test Group',
                'description': 'This is a group for the tests',
            }

            # Missing CSRF
            output = self.app.post('/group/add', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn('<strong>Create new group</strong>', output.data)
            self.assertEqual(output.data.count(
                'This field is required.'), 0)

            data['csrf_token'] = csrf_token

            # All good
            output = self.app.post(
                '/group/add', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      User `pingou` added to '
                'the group `test_group`.', output.data)
            self.assertIn(
                '</button>\n                      Group `test_group` created.',
                output.data)
            self.assertIn(
                '<h2 class="m-b-1">\n'
                '    Groups <span class="label label-default">1</span>',
                output.data)

        user = tests.FakeUser(
            username='******',
            groups=pagure.APP.config['ADMIN_GROUP'])
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/group/add')
            self.assertEqual(output.status_code, 200)
            self.assertIn('<strong>Create new group</strong>', output.data)
            self.assertIn('<option value="admin">admin</option>', output.data)

            data = {
                'group_name': 'test_admin_group',
                'group_type': 'admin',
                'display_name': 'Test Admin Group',
                'description': 'This is another group for the tests',
                'csrf_token': csrf_token,
            }

            # All good
            output = self.app.post(
                '/group/add', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      User `pingou` added to '
                'the group `test_admin_group`.', output.data)
            self.assertIn(
                '</button>\n                      Group `test_admin_group` '
                'created.',output.data)
            self.assertIn(
                '<h2 class="m-b-1">\n'
                '    Groups <span class="label label-default">2</span>',
                output.data)
    def test_package_unretire(self, login_func, utils_module):
        """ Test the package_unretire function. """
        login_func.return_value = None
        create_package_acl(self.session)

        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/rpms/guake/orphan')
            csrf_token = output.data.split(
                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

        # Oprhan and retire guake on F18
        data = {
            'branches': ['f18'],
            'csrf_token': csrf_token,
        }

        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/orphan', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">You are no longer point of contact on '
                'branch: f18</li>' in output.data)

        user = FakeFasUserAdmin()
        with user_set(pkgdb2.APP, user):

            output = self.app.post(
                '/package/rpms/guake/retire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">This package has been retired on '
                'branch: f18</li>' in output.data)

        # Start testing unretire

        with user_set(pkgdb2.APP, user):
            output = self.app.get(
                '/package/rpms/random/unretire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">No package of this name found.</li>'
                in output.data)

            output = self.app.post(
                '/package/rpms/random/unretire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">No package of this name found.</li>'
                in output.data)

            output = self.app.post(
                '/package/rpms/guake/unretire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="error">User &#34;admin&#34; is not in the '
                'packager group</li>' in output.data)

        utils_module.get_packagers.return_value = ['pingou', 'toshio']
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.get(
                '/package/rpms/guake/unretire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<td><select id="branches" multiple name="branches">'
                '<option value="f18">f18</option></select></td>'
                in output.data)

            output = self.app.post(
                '/package/rpms/guake/unretire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">Admins have been asked to un-retire '
                'branch: f18</li>' in output.data)

            output = self.app.post(
                '/package/rpms/guake/unretire/0', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="error">Could not save the request for branch: '
                'f18, has it already been requested?</li>' in output.data)

        # Oprhan and retire guake on master
        data = {
            'branches': ['master'],
            'csrf_token': csrf_token,
        }

        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/orphan', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">You are no longer point of contact on '
                'branch: master</li>' in output.data)

        user = FakeFasUserAdmin()
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/retire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">This package has been retired on '
                'branch: master</li>' in output.data)

        # Ask to un-retire guake on master
        utils_module.get_packagers.return_value = ['pingou', 'toshio']
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.get(
                '/package/rpms/guake/unretire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<td><select id="branches" multiple name="branches">'
                '<option value="master">master</option>' in output.data)

            # Int review_url
            data['review_url'] = '1234'
            output = self.app.post(
                '/package/rpms/guake/unretire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">Admins have been asked to un-retire '
                'branch: master</li>' in output.data)

            # Full URL as review_url
            data['review_url'] = 'https://bugzilla.redhat.com/1234'
            output = self.app.post(
                '/package/rpms/guake/unretire/0', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<li class="error">Could not save the request for branch: '
                'master, has it already been requested?</li>', output.data)
    def test_package_retire(self, login_func, utils_module):
        """ Test the package_retire function. """
        login_func.return_value = None
        create_package_acl(self.session)

        # Check at the very beginning
        output = self.app.get('/package/rpms/guake/')
        self.assertEqual(output.data.count('Obsolete'), 0)
        self.assertEqual(output.data.count('Awaiting Review'), 3)

        data = {
            'branches': ['foobar'],
        }

        user = FakeFasUser()
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/retire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                'class="errors">Only Admins are allowed to retire package '
                'here, you should use `fedpkg retire`.</li>' in output.data)
            csrf_token = output.data.split(
                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

        data = {
            'branches': ['master'],
            'csrf_token': csrf_token,
        }

        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/orphan', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">You are no longer point of contact on '
                'branch: master</li>' in output.data)

            data['branches'] = ['f18']
            output = self.app.post(
                '/package/rpms/guake/orphan', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">You are no longer point of contact on '
                'branch: f18</li>' in output.data)

            # Check after orphaning
            # Orphaning already drops the ACLs of the person doing the action
            output = self.app.get('/package/rpms/guake/')
            self.assertEqual(output.data.count('Obsolete'), 8)
            self.assertEqual(output.data.count('Awaiting Review'), 3)

        data = {
            'branches': ['master'],
            'csrf_token': csrf_token,
        }

        user = FakeFasUser()
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/retire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                'class="errors">Only Admins are allowed to retire package '
                'here, you should use `fedpkg retire`.</li>' in output.data)

        user = FakeFasUserAdmin()
        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/rpms/guake/retire')
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<title> Select branches | PkgDB </title>' in output.data)

            output = self.app.get('/package/rpms/guake/retire/0')
            self.assertEqual(output.status_code, 200)
            self.assertFalse(
                '<title> Select branches | PkgDB </title>' in output.data)

            data['branches'] = ['foobar']
            output = self.app.post(
                '/package/rpms/guake/retire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<td class="errors">&#39;foobar&#39; is not a valid choice '
                'for this field</td>' in output.data)

            # Retire F18 that has been orphaned before
            data['branches'] = ['f18']
            output = self.app.post(
                '/package/rpms/guake/retire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">This package has been retired on '
                'branch: f18</li>' in output.data)

            # Package retired, clear all the ACLs on branch f18
            output = self.app.get('/package/rpms/guake/')
            self.assertEqual(output.data.count('Obsolete'), 8)
            self.assertEqual(output.data.count('Awaiting Review'), 3)

            # Retire branch master
            data['branches'] = ['master']
            output = self.app.post(
                '/package/rpms/guake/retire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">This package has been retired on '
                'branch: master</li>' in output.data)

            # Package retired, clear all the ACLs on master
            output = self.app.get('/package/rpms/guake/')
            self.assertEqual(output.data.count('Obsolete'), 12)
            self.assertEqual(output.data.count('Awaiting Review'), 0)

        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/random/retire', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">No package of this name found.</li>'
                in output.data)
Example #51
0
    def test_view_issue_admin_access(self, p_send_email, p_ugt):
        """ Test the view_issue endpoint. when a user has admin access on repo """
        p_send_email.return_value = True
        p_ugt.return_value = True

        output = self.app.get("/foo/issue/1")
        self.assertEqual(output.status_code, 404)

        tests.create_projects(self.session)
        tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)

        output = self.app.get("/test/issue/1")
        self.assertEqual(output.status_code, 404)

        # Create issues to play with
        repo = pagure.lib.query.get_authorized_project(self.session, "test")

        # Add user 'foo' with ticket access on repo
        msg = pagure.lib.query.add_user_to_project(
            self.session, repo, new_user="******", user="******", access="admin"
        )
        self.assertEqual(msg, "User added")
        self.session.commit()

        repo = pagure.lib.query.get_authorized_project(self.session, "test")
        msg = pagure.lib.query.new_issue(
            session=self.session,
            repo=repo,
            title="Test issue",
            content="We should work on this",
            user="******",
        )

        self.session.commit()
        self.assertEqual(msg.title, "Test issue")

        # Add milestone
        repo.milestones = {"77": None}
        self.session.add(repo)
        issue = pagure.lib.query.search_issues(
            self.session, repo=repo, issueid=1
        )

        pagure.lib.query.edit_issue(
            self.session, issue, user="******", milestone="77"
        )
        self.session.add(repo)
        self.session.add(issue)

        msg = pagure.lib.query.set_custom_key_fields(
            self.session,
            project=repo,
            fields=["abc", "xyz"],
            types=["boolean", "boolean"],
            data=[None, None],
        )
        self.assertEqual(msg, "List of custom fields updated")
        self.session.add(repo)

        msg = pagure.lib.query.set_custom_key_value(
            self.session,
            issue=issue,
            key=pagure.lib.query.get_custom_key(self.session, repo, "abc"),
            value=1,
        )
        self.session.add(issue)
        self.session.commit()

        output = self.app.get("/test/issue/1")
        self.assertEqual(output.status_code, 200)
        # Not authentified = No edit
        self.assertNotIn(
            '<a class="btn btn-outline-secondary btn-sm border-0" '
            'href="/test/issue/1/edit" title="Edit this issue">\n',
            output.get_data(as_text=True),
        )
        self.assertTrue(
            '<a href="/login/?next=http%3A%2F%2Flocalhost%2Ftest%2Fissue%2F1">'
            "Login</a>\n          to comment on this ticket."
            in output.get_data(as_text=True)
        )

        user = tests.FakeUser()
        with tests.user_set(self.app.application, user):
            output = self.app.get("/test/issue/1")
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            # Not author nor admin = No edit
            self.assertNotIn(
                '<a class="btn btn-outline-secondary btn-sm border-0" '
                'href="/test/issue/1/edit" title="Edit this issue">\n',
                output_text,
            )
            self.assertNotIn(
                '<a class="dropdown-item text-danger pointer" id="closeticket"\n'
                '                title="Delete this ticket">\n',
                output_text,
            )

            # no edit metadata
            self.assertNotIn(
                '<a class="btn btn-outline-primary border-0 btn-sm issue-metadata-display'
                ' editmetadatatoggle pointer inline-block">'
                '<i class="fa fa-fw fa-pencil">',
                output_text,
            )
            self.assertNotIn(
                '<a href="/login/">Login</a> to comment on this ticket.',
                output_text,
            )

            # can view the milestone
            self.assertIn("<strong>Milestone</strong>", output_text)
            self.assertIn(
                '<a href="/test/roadmap/77/">\n                  77',
                output_text,
            )
            # but can't edit them
            self.assertNotIn(
                '<select class="form-control c-select" id="milestone" '
                ' name="milestone"><option value=""></option><option '
                'selected value="77">77</option></select>',
                output_text,
            )

            # can view depending
            self.assertIn("<strong>Depending on</strong>", output_text)

            # can't edit depending on
            self.assertNotIn(
                '<input class="form-control" id="depending" type="text"\n\
                                placeholder="issue depending" name="depending"\n\
                                value="" />',
                output_text,
            )

            # no checkbox for private
            self.assertNotIn(
                '<input id="private" name="private" type="checkbox" value="y">',
                output_text,
            )

        user.username = "******"
        with tests.user_set(self.app.application, user):
            output = self.app.get("/test/issue/1")
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)

            # the user can edit the issue
            self.assertIn(
                '<a class="btn btn-outline-secondary btn-sm border-0" '
                'href="/test/issue/1/edit" title="Edit this issue">\n',
                output_text,
            )
            self.assertIn(
                '<a class="dropdown-item text-danger pointer" id="closeticket"\n'
                '                title="Delete this ticket">\n',
                output_text,
            )

            csrf_token = self.get_csrf(output=output)

            # the user can do the following things
            # edit metadata

            self.assertIn(
                '<a class="btn btn-outline-primary border-0 btn-sm '
                "issue-metadata-display editmetadatatoggle pointer inline-block"
                '"><i class="fa fa-fw fa-pencil"></i></a>',
                output_text,
            )

            # can view the milestone
            self.assertIn("<strong>Milestone</strong>", output_text)
            self.assertIn(
                '<a href="/test/roadmap/77/">\n                  77',
                output_text,
            )

            # can edit them
            self.assertIn(
                '<select class="form-control c-select" id="milestone" '
                'name="milestone"><option value=""></option><option selected '
                'value="77">77</option></select>\n      <div>\n',
                output_text,
            )

            # can view depending
            self.assertIn("<strong>Depending on</strong>", output_text)

            # can edit depending on
            self.assertIn(
                '<input class="form-control" id="depending" type="text"'
                '\n                placeholder="issue depending" name="depending"\n',
                output_text,
            )

            # the user should be able to do public -> private
            # the other way round won't be possible since GET and POST
            # to this endpoint for this user will be blocked

            # checkbox for private
            self.assertIn(
                '<input id="private" name="private" type="checkbox" value="y">',
                output_text,
            )

        # Create private issue
        repo = pagure.lib.query.get_authorized_project(self.session, "test")
        msg = pagure.lib.query.new_issue(
            session=self.session,
            repo=repo,
            title="Test issue",
            content="We should work on this",
            user="******",
            private=True,
        )
        self.session.commit()
        self.assertEqual(msg.title, "Test issue")

        # Not logged in
        output = self.app.get("/test/issue/2")
        self.assertEqual(output.status_code, 404)

        # Wrong user
        user = tests.FakeUser()
        with tests.user_set(self.app.application, user):
            output = self.app.get("/test/issue/2")
            self.assertEqual(output.status_code, 404)

        # reporter
        user.username = "******"
        with tests.user_set(self.app.application, user):
            output = self.app.get("/test/issue/2")
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                "<title>Issue #2: Test issue - test - Pagure</title>",
                output_text,
            )
            self.assertIn(
                '<span title="Private ticket" class="text-danger '
                'fa fa-fw fa-lock"></span>',
                output_text,
            )
            self.assertIn(
                '<a class="btn btn-outline-secondary btn-sm border-0" '
                'href="/test/issue/2/edit" title="Edit this issue">\n',
                output_text,
            )
    def test_view_group(self):
        """ Test the view_group endpoint. """
        output = self.app.get('/group/foo')
        self.assertEqual(output.status_code, 404)

        self.test_add_group()

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/group/test_group')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> &nbsp;'
                'Test Group', output.data)

            output = self.app.get('/group/test_admin_group')
            self.assertEqual(output.status_code, 404)

        user = tests.FakeUser(
            username='******',
            groups=pagure.APP.config['ADMIN_GROUP'])
        with tests.user_set(pagure.APP, user):
            # Admin can see group of type admins
            output = self.app.get('/group/test_admin_group')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> &nbsp;'
                'Test Admin Group', output.data)
            self.assertEqual(output.data.count('<a href="/user/'), 1)

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

            # No CSRF
            data = {
                'user': '******'
            }

            output = self.app.post('/group/test_admin_group', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> &nbsp;'
                'Test Admin Group', output.data)
            self.assertEqual(output.data.count('<a href="/user/'), 1)

            # Invalid user
            data = {
                'user': '******',
                'csrf_token': csrf_token,
            }
            output = self.app.post(
                '/group/test_admin_group', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      No user `bar` found',
                output.data)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> &nbsp;'
                'Test Admin Group', output.data)
            self.assertEqual(output.data.count('<a href="/user/'), 1)

            # All good
            data = {
                'user': '******',
                'csrf_token': csrf_token,
            }
            output = self.app.post('/group/test_admin_group', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '</button>\n                      User `foo` added to the '
                'group `test_admin_group`.', output.data)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> &nbsp;'
                'Test Admin Group', output.data)
            self.assertEqual(output.data.count('<a href="/user/'), 2)
    def test_plugin_pagure_request(self):
        """ Test the pagure_request plugin on/off endpoint. """

        tests.create_projects(self.session)
        tests.create_projects_git(os.path.join(self.path, 'repos'))

        user = tests.FakeUser(username='******')
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/test/settings/Read the Doc')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertIn('<h3>Read the Doc settings</h3>', output.data)
            self.assertIn(
                '<input id="active" name="active" type="checkbox" value="y">',
                output.data)

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

            data = {}

            output = self.app.post('/test/settings/Read the Doc', data=data)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertIn('<h3>Read the Doc settings</h3>', output.data)
            self.assertIn(
                '<input id="active" name="active" type="checkbox" value="y">',
                output.data)

            data['csrf_token'] = csrf_token

            # Create the requests repo
            tests.create_projects_git(os.path.join(self.path, 'requests'))

            output = self.app.post('/test/settings/Read the Doc',
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<section class="settings">\n  <h3>Settings for test</h3>',
                output.data)
            self.assertIn(
                '</button>\n                      Hook Read the Doc deactivated',
                output.data)

            output = self.app.get('/test/settings/Read the Doc')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertIn('<h3>Read the Doc settings</h3>', output.data)
            self.assertIn(
                '<input id="active" name="active" type="checkbox" value="y">',
                output.data)

            self.assertFalse(
                os.path.exists(
                    os.path.join(self.path, 'requests', 'test.git', 'hooks',
                                 'post-receive.pagure')))

            # Activate hook
            data = {
                'csrf_token': csrf_token,
                'active': 'y',
                'project_name': 'foo',
            }

            output = self.app.post('/test/settings/Read the Doc',
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<section class="settings">\n  <h3>Settings for test</h3>',
                output.data)
            self.assertIn(
                '</button>\n                      Hook Read the Doc activated',
                output.data)

            output = self.app.get('/test/settings/Read the Doc')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertIn('<h3>Read the Doc settings</h3>', output.data)
            self.assertIn(
                '<input checked id="active" name="active" type="checkbox" '
                'value="y">', output.data)

            self.assertTrue(
                os.path.exists(
                    os.path.join(self.path, 'repos', 'test.git', 'hooks',
                                 'post-receive.rtd')))

            # De-Activate hook
            data = {'csrf_token': csrf_token}
            output = self.app.post('/test/settings/Read the Doc',
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<section class="settings">\n  <h3>Settings for test</h3>',
                output.data)
            self.assertIn(
                '</button>\n                      Hook Read the Doc deactivated',
                output.data)

            output = self.app.get('/test/settings/Read the Doc')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<div class="projectinfo m-t-1 m-b-1">\n'
                'test project #1        </div>', output.data)
            self.assertIn('<h3>Read the Doc settings</h3>', output.data)
            self.assertIn(
                '<input id="active" name="active" type="checkbox" '
                'value="y">', output.data)

            self.assertFalse(
                os.path.exists(
                    os.path.join(self.path, 'repos', 'test.git', 'hooks',
                                 'post-receive.rtd')))

            # Try re-activate hook w/o the git repo
            data = {
                'csrf_token': csrf_token,
                'active': 'y',
                'project_name': 'foo',
            }
            shutil.rmtree(os.path.join(self.path, 'repos', 'test.git'))

            output = self.app.post('/test/settings/Read the Doc', data=data)
            self.assertEqual(output.status_code, 404)
Example #54
0
    def test_edit_pr(self):
        """Tests the ACLs if they only accept PRs."""
        self.set_auth_status({'refs/heads/master': 'pronly',
                              'refs/heads/source': True})

        user = tests.FakeUser()
        user.username = '******'
        with tests.user_set(self.app.application, user):
            # Add some content to the git repo
            tests.add_content_git_repo(
                os.path.join(self.path, 'repos', 'hooktest.git'))

            # Try editing master branch, should fail (only PRs allowed)
            data = {
                'content': 'foo\n bar\n  baz',
                'commit_title': 'test commit',
                'commit_message': 'Online commits from the gure.lib.get',
                'email': '*****@*****.**',
                'branch': 'master',
                'csrf_token': self.get_csrf(),
            }
            output = self.app.post(
                '/hooktest/edit/master/f/sources', data=data,
                follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                "Remote hook declined the push: "
                "Denied push for ref &#39;refs/heads/master&#39; for user &#39;pingou&#39;\n"
                "All changes have been rejected",
                output_text
            )

            # Change something in the "source" branch
            data = {
                'content': 'foo\n bar\n  baz',
                'commit_title': 'test commit',
                'commit_message': 'Online commits from the gure.lib.get',
                'email': '*****@*****.**',
                'branch': 'source',
                'csrf_token': self.get_csrf(),
            }

            output = self.app.post(
                '/hooktest/edit/master/f/sources', data=data,
                follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                '<title>Commits - hooktest - Pagure</title>', output_text)
            self.assertIn('test commit', output_text)

            # Check file after the commit:
            output = self.app.get('/hooktest/raw/source/f/sources')
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertEqual(output_text, 'foo\n bar\n  baz')

            # Create the PRs
            project = pagure.lib.query.get_authorized_project(self.session, 'hooktest')
            req = pagure.lib.query.new_pull_request(
                session=self.session,
                repo_from=project,
                branch_from="source",
                repo_to=project,
                branch_to='master',
                title='PR to master',
                user='******',
            )
            self.session.add(req)
            self.session.commit()

            # Check file before the merge
            output = self.app.get('/hooktest/raw/master/f/sources')
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertEqual(output_text, 'foo\n bar')

            # Try to merge (should work)
            output = self.app.post(
                '/hooktest/pull-request/1/merge', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                '<title>Overview - hooktest - Pagure</title>',
                output_text
            )

            # Check file after the merge
            output = self.app.get('/hooktest/raw/master/f/sources')
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertEqual(output_text, 'foo\n bar\n  baz')
    def test_package_orphan(self, login_func, utils_module):
        """ Test the package_orphan function. """
        login_func.return_value = None
        create_package_acl(self.session)

        user = FakeFasUser()
        user.username = '******'
        with user_set(pkgdb2.APP, user):
            output = self.app.get('/package/rpms/guake/orphan')
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<title> Select branches | PkgDB </title>' in output.data)

            output = self.app.get('/package/rpms/guake/orphan/0')
            self.assertEqual(output.status_code, 200)
            self.assertFalse(
                '<title> Select branches | PkgDB </title>' in output.data)

            output = self.app.post(
                '/package/rpms/guake/orphan', follow_redirects=True,
                data={'branches': ['master']})
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                'class="errors">&#39;master&#39; is not a valid choice for '
                'this field</td>' in output.data)
            csrf_token = output.data.split(
                'name="csrf_token" type="hidden" value="')[1].split('">')[0]

        data = {
            'branches': ['master'],
            'csrf_token': csrf_token,
        }

        user = FakeFasUser()
        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/guake/orphan', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="message">You are no longer point of contact on '
                'branch: master</li>' in output.data)

            # You cannot orphan twice the same package, the branch is no
            # longer available
            output = self.app.post(
                '/package/rpms/guake/orphan', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<td class="errors">&#39;master&#39; is not a valid choice '
                'for this field</td>' in output.data)

        with user_set(pkgdb2.APP, user):
            output = self.app.post(
                '/package/rpms/random/orphan', follow_redirects=True,
                data=data)
            self.assertEqual(output.status_code, 200)
            self.assertTrue(
                '<li class="errors">No package of this name found.</li>'
                in output.data)
    def test_no_form_with_disabled_issues_and_pull_requests(self):
        self.disable_issues_and_pull_requests()

        with tests.user_set(self.app.application, self.admin):
            output = self.app.get('/test/settings')
            self.assertNotIn('Quick replies', output.data)
    def test_roadmap_ui(self, p_send_email, p_ugt):
        """ Test viewing the roadmap of a repo. """
        p_send_email.return_value = True
        p_ugt.return_value = True

        self.test_update_milestones()

        user = tests.FakeUser()
        user.username = "******"
        with tests.user_set(self.app.application, user):

            # Get the CSRF token
            output = self.app.get("/test/new_issue")
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertTrue(
                '<h4 class="font-weight-bold mb-4">New Issue</h4>\n' in
                output_text)

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

            # Create an unplanned milestone
            data = {
                "milestones": [1, 2, 3],
                "milestone_1_name": "v1.0",
                "milestone_2_name": "v2.0",
                "milestone_3_name": "unplanned",
                "milestone_1_date": "Tomorrow",
                "milestone_2_date": "",
                "milestone_3_date": "",
                "milestone_1_active": True,
                "milestone_2_active": True,
                "milestone_3_active": True,
                "csrf_token": csrf_token,
            }
            output = self.app.post("/test/update/milestones",
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            # Check the redirect
            self.assertIn("<title>Settings - test - Pagure</title>",
                          output_text)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                "Project Settings</h5>\n",
                output_text,
            )
            self.assertIn("Milestones updated", output_text)

            # Check the result of the action -- Milestones recorded
            self.session.commit()
            repo = pagure.lib.query._get_project(self.session, "test")
            self.assertEqual(
                repo.milestones,
                {
                    "unplanned": {
                        "active": True,
                        "date": None
                    },
                    "v1.0": {
                        "active": True,
                        "date": "Tomorrow"
                    },
                    "v2.0": {
                        "active": True,
                        "date": None
                    },
                },
            )

            # Create the issues
            for cnt in range(6):
                cnt += 1
                data = {
                    "title":
                    "Test issue %s" % cnt,
                    "issue_content":
                    "We really should improve on this "
                    "issue %s" % cnt,
                    "csrf_token":
                    csrf_token,
                }

                output = self.app.post("/test/new_issue",
                                       data=data,
                                       follow_redirects=True)
                self.assertEqual(output.status_code, 200)
                output_text = output.get_data(as_text=True)
                self.assertIn(
                    "<title>Issue #{0}: Test issue {0} - test - "
                    "Pagure</title>".format(cnt),
                    output_text,
                )
                self.assertIn(
                    '<a class="btn btn-outline-secondary btn-sm border-0" '
                    'href="/test/issue/%s/edit" title="Edit this issue">' %
                    cnt,
                    output_text,
                )

                # Mark the ticket for the roadmap
                mstone = "v%s.0" % cnt
                if cnt >= 3:
                    if (cnt % 3) == 0:
                        mstone = "unplanned"
                    else:
                        mstone = "v%s.0" % (cnt % 3)
                data = {"milestone": mstone, "csrf_token": csrf_token}
                output = self.app.post(
                    "/test/issue/%s/update" % cnt,
                    data=data,
                    follow_redirects=True,
                )
                self.assertEqual(output.status_code, 200)
                output_text = output.get_data(as_text=True)
                self.assertIn(
                    "<title>Issue #{0}: Test issue {0} - test - "
                    "Pagure</title>".format(cnt),
                    output_text,
                )
                self.assertIn(
                    '<a class="btn btn-outline-secondary btn-sm border-0" '
                    'href="/test/issue/%s/edit" title="Edit this issue">' %
                    cnt,
                    output_text,
                )
                self.assertIn("Issue set to the milestone: %s" % mstone,
                              output_text)
                self.assertIn('<div class="ml-2" id="milestone_plain">',
                              output_text)
                self.assertIn('<a href="/test/roadmap/%s/">' % mstone,
                              output_text)

        repo = pagure.lib.query.get_authorized_project(self.session, "test")

        # Mark ticket #1 as Fixed
        for iid in [1, 4]:
            ticket = pagure.lib.query.search_issues(self.session,
                                                    repo,
                                                    issueid=iid)
            ticket.status = "Closed"
            ticket.close_status = "Fixed"
            self.session.add(ticket)
            self.session.commit()

        # test the roadmap view
        output = self.app.get("/test/roadmap")
        self.assertEqual(output.status_code, 200)
        output_text = output.get_data(as_text=True)
        self.assertIn(
            '<span class="fa fa-fw fa-map-signs"></span>\n'
            '                            <span class="font'
            '-weight-bold">v1.0</span>',
            output_text,
        )
        self.assertIn(
            '<span class="fa fa-fw fa-map-signs"></span>\n'
            '                            <span class="font'
            '-weight-bold">unplanned</span>',
            output_text,
        )
        self.assertIn(
            'title="100% Completed | 2 Closed Issues | 0 Open Issues"\n',
            output_text,
        )
        self.assertIn(
            'title="0% Completed | 0 Closed Issues | 2 Open Issues"\n',
            output_text,
        )
        self.assertIn(
            'title="0% Completed | 0 Closed Issues | 2 Open Issues"\n',
            output_text,
        )

        # test the roadmap view for a specific milestone
        output = self.app.get("/test/roadmap/v2.0/")
        self.assertEqual(output.status_code, 200)
        output_text = output.get_data(as_text=True)
        self.assertIn(
            '<span class="fa fa-fw fa-exclamation-circle"></span> 2 Open\n',
            output_text,
        )
        self.assertIn(
            '<span class="fa fa-fw fa-exclamation-circle"></span> 0 Closed\n',
            output_text,
        )
        self.assertIn('<a class="notblue" href="/test/issue/2">', output_text)
        self.assertEquals(
            output_text.count('<a class="notblue" href="/test/issue/2">'), 1)

        # test the roadmap view for errors
        output = self.app.get("/foo/roadmap")
        self.assertEqual(output.status_code, 404)

        repo = pagure.lib.query.get_authorized_project(self.session, "test")
        settings = repo.settings
        settings["issue_tracker"] = False
        repo.settings = settings
        self.session.add(repo)
        self.session.commit()

        output = self.app.get("/test/roadmap", data=data)
        self.assertEqual(output.status_code, 404)
    def test_edit_group(self):
        """ Test the edit_group endpoint. """

        output = self.app.get('/group/test_group/edit')
        self.assertEqual(output.status_code, 302)

        user = tests.FakeUser()
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/group/test_group/edit')
            self.assertEqual(output.status_code, 404)
            self.assertIn('<p>Group not found</p>', output.data)

        self.test_add_group()

        user.username = '******'
        with tests.user_set(pagure.APP, user):
            output = self.app.get('/group/foo/edit')
            self.assertEqual(output.status_code, 404)
            self.assertIn('<p>Group not found</p>', output.data)

            output = self.app.get('/group/test_group/edit')
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<title>Edit group: test_group - Pagure</title>',
                output.data)
            self.assertIn(
                '<form action="/group/test_group/edit" method="post">',
                output.data)
            self.assertIn(
                '<strong><label for="description">Description'
                '</label></strong>', output.data)

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

            # Missing CSRF
            data = {
                'group_name': 'test_group',
                'display_name': 'Test Group edited',
                'description': 'This is a group for the tests edited',
            }

            output = self.app.post(
                '/group/test_group/edit', data=data, follow_redirects=True)
            #print output.data
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<title>Edit group: test_group - Pagure</title>',
                output.data)
            self.assertIn(
                '<form action="/group/test_group/edit" method="post">',
                output.data)
            self.assertIn(
                '<strong><label for="description">Description'
                '</label></strong>', output.data)

            # User not allowed
            data['csrf_token'] = csrf_token

            output = self.app.post(
                '/group/test_group/edit', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<title>Group test_group - Pagure</title>',
                output.data)
            self.assertIn(
                '</button>\n                      You are not '
                'allowed to edit this group', output.data)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> '
                '&nbsp;Test Group', output.data)

        user.username = '******'
        with tests.user_set(pagure.APP, user):
            # Invalid repo
            output = self.app.post(
                '/group/bar/edit', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 404)
            self.assertIn('<p>Group not found</p>', output.data)

            output = self.app.post(
                '/group/test_group/edit', data=data, follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            self.assertIn(
                '<title>Group test_group - Pagure</title>', output.data)
            self.assertIn(
                '<span class="oi" data-glyph="people"></span> '
                '&nbsp;Test Group', output.data)
            self.assertIn(
                'Group &#34;Test Group edited&#34; (test_group) edited',
                output.data)
    def test_update_milestones(self):
        """ Test updating milestones of a repo. """
        tests.create_projects(self.session)
        tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)

        # Set some milestones
        repo = pagure.lib.query.get_authorized_project(self.session, "test")
        self.assertEqual(repo.milestones, {})

        user = tests.FakeUser()
        user.username = "******"
        with tests.user_set(self.app.application, user):

            # Get the CSRF token
            output = self.app.get("/test/settings")
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn("<title>Settings - test - Pagure</title>",
                          output_text)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                "Project Settings</h5>\n",
                output_text,
            )

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

            data = {
                "milestones": 1,
                "milestone_1_name": "1",
                "milestone_1_date": "Tomorrow",
            }
            output = self.app.post("/test/update/milestones",
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            # Check the redirect
            self.assertIn("<title>Settings - test - Pagure</title>",
                          output_text)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                "Project Settings</h5>\n",
                output_text,
            )
            # Check the result of the action -- None, no CSRF
            repo = pagure.lib.query.get_authorized_project(
                self.session, "test")
            self.assertEqual(repo.milestones, {})

            data = {
                "milestones": 1,
                "milestone_1_name": "1",
                "milestone_date": "",
                "csrf_token": csrf_token,
            }
            output = self.app.post("/test/update/milestones",
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            # Check the redirect
            self.assertIn("<title>Settings - test - Pagure</title>",
                          output_text)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                "Project Settings</h5>\n",
                output_text,
            )
            self.assertIn("Milestones updated", output_text)

            # Check the result of the action -- Milestones recorded
            self.session.commit()
            repo = pagure.lib.query.get_authorized_project(
                self.session, "test")
            self.assertEqual(repo.milestones,
                             {"1": {
                                 "active": False,
                                 "date": None
                             }})

            data = {
                "milestones": [1, 2],
                "milestone_1_name": "v1.0",
                "milestone_2_name": "v2.0",
                "milestone_1_date": "Tomorrow",
                "milestone_2_date": "",
                "csrf_token": csrf_token,
            }
            output = self.app.post("/test/update/milestones",
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            # Check the redirect
            self.assertIn("<title>Settings - test - Pagure</title>",
                          output_text)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                "Project Settings</h5>\n",
                output_text,
            )
            self.assertIn("Milestones updated", output_text)
            # Check the result of the action -- Milestones recorded
            self.session.commit()
            repo = pagure.lib.query.get_authorized_project(
                self.session, "test")
            self.assertEqual(
                repo.milestones,
                {
                    "v1.0": {
                        "active": False,
                        "date": "Tomorrow"
                    },
                    "v2.0": {
                        "active": False,
                        "date": None
                    },
                },
            )

            # Check error - less milestones than dates
            data = {
                "milestones": [1, 2],
                "milestone_1_name": "v1.0",
                "milestone_2_name": "v2.0",
                "milestone_1_date": "Tomorrow",
                "milestone_2_date": "Next week",
                "milestone_3_date": "Next Year",
                "csrf_token": csrf_token,
            }
            output = self.app.post("/test/update/milestones",
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            # Check the redirect
            self.assertIn("<title>Settings - test - Pagure</title>",
                          output_text)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                "Project Settings</h5>\n",
                output_text,
            )
            # Check the result of the action -- Milestones un-changed
            self.session.commit()
            repo = pagure.lib.query.get_authorized_project(
                self.session, "test")
            self.assertEqual(
                repo.milestones,
                {
                    "v1.0": {
                        "active": False,
                        "date": "Tomorrow"
                    },
                    "v2.0": {
                        "active": False,
                        "date": "Next week"
                    },
                },
            )

            # Check error - Twice the same milestone
            data = {
                "milestones": [1, 2, 3],
                "milestone_1_name": "v1.0",
                "milestone_2_name": "v2.0",
                "milestone_3_name": "v2.0",
                "milestone_1_date": "Tomorrow",
                "milestone_2_date": "Next week",
                "milestone_3_date": "Next Year",
                "csrf_token": csrf_token,
            }
            output = self.app.post("/test/update/milestones",
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            # Check the redirect
            self.assertIn("<title>Settings - test - Pagure</title>",
                          output_text)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                "Project Settings</h5>\n",
                output_text,
            )
            self.assertIn(
                "Milestone v2.0 is present multiple times",
                "Milestone v2.0 is present multiple times",
                output_text,
            )
            # Check the result of the action -- Milestones un-changed
            self.session.commit()
            repo = pagure.lib.query.get_authorized_project(
                self.session, "test")
            self.assertEqual(
                repo.milestones,
                {
                    "v1.0": {
                        "active": False,
                        "date": "Tomorrow"
                    },
                    "v2.0": {
                        "active": False,
                        "date": "Next week"
                    },
                },
            )

            # Check error - Twice the same date
            data = {
                "milestones": [1, 2, 3],
                "milestone_1_name": "v1.0",
                "milestone_2_name": "v2.0",
                "milestone_3_name": "v3.0",
                "milestone_1_date": "Tomorrow",
                "milestone_2_date": "Next week",
                "milestone_3_date": "Next week",
                "csrf_token": csrf_token,
            }
            output = self.app.post("/test/update/milestones",
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            # Check the redirect
            self.assertIn("<title>Settings - test - Pagure</title>",
                          output_text)
            self.assertIn(
                '<h5 class="pl-2 font-weight-bold text-muted">'
                "Project Settings</h5>\n",
                output_text,
            )
            self.assertIn("Milestones updated", output_text)
            # Check the result of the action -- Milestones updated
            self.session.commit()
            repo = pagure.lib.query.get_authorized_project(
                self.session, "test")
            self.assertEqual(
                repo.milestones,
                {
                    "v1.0": {
                        "active": False,
                        "date": "Tomorrow"
                    },
                    "v2.0": {
                        "active": False,
                        "date": "Next week"
                    },
                    "v3.0": {
                        "active": False,
                        "date": "Next week"
                    },
                },
            )

            # Check for an invalid project
            output = self.app.post("/foo/update/milestones", data=data)
            self.assertEqual(output.status_code, 404)

            # Check the behavior if the project disabled the issue tracker
            settings = repo.settings
            settings["issue_tracker"] = False
            repo.settings = settings
            self.session.add(repo)
            self.session.commit()

            output = self.app.post("/test/update/milestones", data=data)
            self.assertEqual(output.status_code, 404)

        # Check for a non-admin user
        settings = repo.settings
        settings["issue_tracker"] = True
        repo.settings = settings
        self.session.add(repo)
        self.session.commit()

        user.username = "******"
        with tests.user_set(self.app.application, user):
            output = self.app.post("/test/update/milestones", data=data)
            self.assertEqual(output.status_code, 403)
    def test_ticket_with_roadmap(self, p_send_email, p_ugt):
        """ Test creating a ticket with roadmap. """
        p_send_email.return_value = True
        p_ugt.return_value = True

        tests.create_projects(self.session)
        tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)

        # Set some milestone
        repo = pagure.lib.query.get_authorized_project(self.session, "test")
        repo.milestone = {"v1.0": "", "v2.0": "Tomorrow!"}
        self.session.add(repo)
        self.session.commit()

        user = tests.FakeUser()
        user.username = "******"
        with tests.user_set(self.app.application, user):

            # Get the CSRF token
            output = self.app.get("/test/new_issue")
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertTrue(
                '<h4 class="font-weight-bold mb-4">New Issue</h4>\n' in
                output_text)

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

            data = {
                "title": "Test issue",
                "issue_content": "We really should improve on this issue",
                "status": "Open",
                "csrf_token": csrf_token,
            }

            # Create the issue
            output = self.app.post("/test/new_issue",
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                "<title>Issue #1: Test issue - test - Pagure</title>",
                output_text,
            )
            self.assertIn(
                '<a class="btn btn-outline-secondary btn-sm border-0" '
                'href="/test/issue/1/edit" title="Edit this issue">',
                output_text,
            )

            # Mark the ticket for the roadmap
            data = {"tag": "roadmap", "csrf_token": csrf_token}
            output = self.app.post("/test/issue/1/update",
                                   data=data,
                                   follow_redirects=True)
            self.assertEqual(output.status_code, 200)
            output_text = output.get_data(as_text=True)
            self.assertIn(
                "<title>Issue #1: Test issue - test - Pagure</title>",
                output_text,
            )
            self.assertIn(
                '<a class="btn btn-outline-secondary btn-sm border-0" '
                'href="/test/issue/1/edit" title="Edit this issue">',
                output_text,
            )