| |
| |
| """ |
| (c) 2015-2018 - Copyright Red Hat Inc |
| |
| Authors: |
| Pierre-Yves Chibon <pingou@pingoured.fr> |
| |
| """ |
| |
| from __future__ import unicode_literals, absolute_import |
| |
| import datetime |
| import unittest |
| import shutil |
| import sys |
| import tempfile |
| import os |
| |
| import six |
| import json |
| import pygit2 |
| from mock import patch, MagicMock |
| |
| sys.path.insert(0, os.path.join(os.path.dirname( |
| os.path.abspath(__file__)), '..')) |
| |
| import pagure.lib.query |
| import tests |
| |
| |
| class PagureFlaskApptests(tests.Modeltests): |
| """ Tests for flask app controller of pagure """ |
| |
| def test_watch_list(self): |
| ''' Test for watch list of a user ''' |
| |
| user = tests.FakeUser(username='pingou') |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/', follow_redirects=True) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<div class="text-center">You have no Projects</div>', |
| output_text) |
| |
| tests.create_projects(self.session) |
| |
| output = self.app.get('/', follow_redirects=True) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<h4 class="font-weight-bold mb-0">My Projects</h4>', |
| output_text) |
| |
| def test_view_users(self): |
| """ Test the view_users endpoint. """ |
| |
| output = self.app.get('/users/?page=abc') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<h3 class="mb-3 font-weight-bold">\n Users ' |
| '<span class="badge badge-secondary">2</span>', output_text) |
| self.assertIn( |
| '<a href="/user/pingou">\n ' |
| '<div class="nowrap"><strong>pingou</strong>', |
| output_text) |
| self.assertIn( |
| '<a href="/user/foo">\n ' |
| '<div class="nowrap"><strong>foo</strong>', |
| output_text) |
| |
| @patch.dict('pagure.config.config', {'ITEM_PER_PAGE': 2}) |
| def test_view_user_repo_cnt(self): |
| """ Test the repo counts on the view_user endpoint. """ |
| tests.create_projects(self.session) |
| self.gitrepos = tests.create_projects_git( |
| pagure.config.config['GIT_FOLDER']) |
| |
| output = self.app.get('/user/pingou') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| """<span> |
| <i class="fa fa-fw text-muted fa-calendar-o fa-rotate-270"></i> |
| <span class="d-none d-md-inline">Projects </span> |
| </span> |
| <div class="ml-auto"> |
| <span class="badge badge-secondary"> |
| 3 |
| </span> |
| </div>""", output_text) |
| self.assertIn( |
| """<span> |
| <i class="fa fa-fw text-muted fa-code-fork"></i> |
| <span class="d-none d-md-inline">Forks </span> |
| </span> |
| <div class="ml-auto"> |
| <span class="badge badge-secondary"> |
| 0 |
| </span> |
| </div>""", output_text) |
| |
| def test_view_user(self): |
| """ Test the view_user endpoint. """ |
| |
| output = self.app.get('/user/pingou?repopage=abc&forkpage=def') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| """<span> |
| <i class="fa fa-fw text-muted fa-calendar-o fa-rotate-270"></i> |
| <span class="d-none d-md-inline">Projects </span> |
| </span> |
| <div class="ml-auto"> |
| <span class="badge badge-secondary"> |
| 0 |
| </span> |
| </div>""", output_text) |
| self.assertIn( |
| """<span> |
| <i class="fa fa-fw text-muted fa-code-fork"></i> |
| <span class="d-none d-md-inline">Forks </span> |
| </span> |
| <div class="ml-auto"> |
| <span class="badge badge-secondary"> |
| 0 |
| </span> |
| </div>""", output_text) |
| |
| tests.create_projects(self.session) |
| self.gitrepos = tests.create_projects_git( |
| pagure.config.config['GIT_FOLDER']) |
| |
| output = self.app.get('/user/pingou?repopage=abc&forkpage=def') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| """<span> |
| <i class="fa fa-fw text-muted fa-calendar-o fa-rotate-270"></i> |
| <span class="d-none d-md-inline">Projects </span> |
| </span> |
| <div class="ml-auto"> |
| <span class="badge badge-secondary"> |
| 3 |
| </span> |
| </div>""", output_text) |
| self.assertIn( |
| """<span> |
| <i class="fa fa-fw text-muted fa-code-fork"></i> |
| <span class="d-none d-md-inline">Forks </span> |
| </span> |
| <div class="ml-auto"> |
| <span class="badge badge-secondary"> |
| 0 |
| </span> |
| </div>""", output_text) |
| self.assertNotIn( |
| '<a class="page-link" href="#" tabindex="-1">page 1 of 2</a>', |
| output_text) |
| |
| @patch.dict('pagure.config.config', {'ENABLE_UI_NEW_PROJECTS': False}) |
| def test_new_project_when_turned_off_in_the_ui(self): |
| """ Test the new_project endpoint when new project creation is |
| not allowed in the UI of this pagure instance. """ |
| |
| user = tests.FakeUser(username='foo') |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/') |
| self.assertEqual(output.status_code, 404) |
| |
| data = { |
| 'description': 'Project #1', |
| 'name': 'project-1', |
| } |
| |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 404) |
| |
| @patch.dict('pagure.config.config', {'ENABLE_UI_NEW_PROJECTS': False}) |
| def test_new_project_button_when_turned_off_in_the_ui_no_project(self): |
| """ Test the index endpoint when new project creation is |
| not allowed in the UI of this pagure instance. """ |
| |
| user = tests.FakeUser(username='foo') |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/', follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<h4 class="font-weight-bold mb-0">My Projects</h4>', |
| output_text) |
| |
| self.assertNotIn( |
| '<span class="oi" data-glyph="plus" title="Create New"', |
| output_text) |
| |
| self.assertNotIn( |
| 'title="Create New Project" aria-hidden="true">', |
| output_text) |
| |
| @patch.dict('pagure.config.config', {'ENABLE_UI_NEW_PROJECTS': False}) |
| def test_new_project_button_when_turned_off_in_the_ui_w_project(self): |
| """ Test the index endpoint when new project creation is |
| not allowed in the UI of this pagure instance. """ |
| tests.create_projects(self.session) |
| |
| user = tests.FakeUser(username='pingou') |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/', follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<h4 class="font-weight-bold mb-0">My Projects</h4>', |
| output_text) |
| |
| self.assertNotIn( |
| '<span class="oi" data-glyph="plus" title="Create New"', |
| output_text) |
| |
| self.assertNotIn( |
| 'title="Create New Project" aria-hidden="true">', |
| output_text) |
| |
| def test_new_project_with_dot(self): |
| """ Test the new_project endpoint when new project contains a dot. |
| """ |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| |
| user = tests.FakeUser(username="foo") |
| with tests.user_set(self.app.application, user): |
| csrf_token = self.get_csrf() |
| |
| data = { |
| 'description': 'Project #1.', |
| 'name': 'project.1', |
| 'csrf_token': csrf_token |
| } |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>Overview - project.1 - Pagure</title>', output_text) |
| self.assertIn( |
| '<a href="/project.1"><strong>project.1</strong></a>', |
| output_text |
| ) |
| |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 1) |
| |
| def test_new_project_with_plus(self): |
| """ Test the new_project endpoint when new project contains a plus sign. |
| """ |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| |
| user = tests.FakeUser(username="foo") |
| with tests.user_set(self.app.application, user): |
| csrf_token = self.get_csrf() |
| |
| data = { |
| 'description': 'Project #1.', |
| 'name': 'project+1', |
| 'csrf_token': csrf_token |
| } |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>Overview - project+1 - Pagure</title>', output_text) |
| self.assertTrue( |
| '<a href="/project+1"><strong>project+1</strong></a>' in |
| output_text |
| or |
| '<a href="/project%2B1"><strong>project+1</strong></a>' in |
| output_text |
| ) |
| |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 1) |
| |
| def test_new_project_when_turned_off(self): |
| """ Test the new_project endpoint when new project creation is |
| not allowed in the pagure instance. """ |
| |
| |
| pagure.config.config['ENABLE_NEW_PROJECTS'] = False |
| |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', 'project-1.git'))) |
| |
| user = tests.FakeUser() |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/') |
| self.assertEqual(output.status_code, 404) |
| |
| |
| pagure.config.config['ENABLE_NEW_PROJECTS'] = True |
| output = self.app.get('/new/') |
| pagure.config.config['ENABLE_NEW_PROJECTS'] = False |
| |
| csrf_token = output.get_data(as_text=True).split( |
| 'name="csrf_token" type="hidden" value="')[1].split('">')[0] |
| |
| data = { |
| 'description': 'Project #1', |
| 'name': 'project-1', |
| } |
| |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| data['csrf_token'] = csrf_token |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 404) |
| |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', 'project-1.git'))) |
| |
| pagure.config.config['ENABLE_NEW_PROJECTS'] = True |
| |
| def test_new_project_mirrored_invalid_url(self): |
| """ Test the new_project with a mirrored repo but an invalid URL. """ |
| |
| user = tests.FakeUser(username='foo') |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/') |
| self.assertEqual(output.status_code, 200) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| data = { |
| 'description': 'Project #1', |
| 'name': 'project-1', |
| 'mirrored_from': 'abcd', |
| 'csrf_token': csrf_token, |
| } |
| |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>New project - Pagure</title>', output_text) |
| self.assertIn( |
| 'Invalid input. ', output_text) |
| |
| def test_new_project_mirrored_invalid_sshurl(self): |
| """ Test the new_project with a mirrored repo but an invalid |
| SSH-like url. |
| """ |
| |
| user = tests.FakeUser(username='foo') |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/') |
| self.assertEqual(output.status_code, 200) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| data = { |
| 'description': 'Project #1', |
| 'name': 'project-1', |
| 'mirrored_from': 'ssh://git@server.org/foo/bar.git', |
| 'csrf_token': csrf_token, |
| } |
| |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>New project - Pagure</title>', output_text) |
| self.assertIn( |
| 'Invalid input. ', output_text) |
| |
| def test_new_project_mirrored_valid_url(self): |
| """ Test the new_project with a mirrored repo with a valid url. """ |
| |
| user = tests.FakeUser(username='foo') |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<strong><label for="mirrored_from">Mirror from URL' |
| '</label></strong>', output_text) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| data = { |
| 'description': 'Project #1', |
| 'name': 'project-1', |
| 'mirrored_from': 'https://example.com/foo/bar.git', |
| 'csrf_token': csrf_token, |
| } |
| |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>Overview - project-1 - Pagure</title>', |
| output_text) |
| self.assertIn( |
| '<p>This repo is brand new and meant to be mirrored from ' |
| 'https://example.com/foo/bar.git !</p>', output_text) |
| |
| @patch.dict('pagure.config.config', {'DISABLE_MIRROR_IN': True}) |
| def test_new_project_mirrored_mirror_disabled(self): |
| """ Test the new_project with a mirrored repo when that feature is |
| disabled. |
| """ |
| |
| user = tests.FakeUser(username='foo') |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertNotIn( |
| '<strong><label for="mirrored_from">Mirror from URL' |
| '</label></strong>', output_text) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| data = { |
| 'description': 'Project #1', |
| 'name': 'project-1', |
| 'mirrored_from': 'https://example.com/foo/bar.git', |
| 'csrf_token': csrf_token, |
| } |
| |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>New project - Pagure</title>', output_text) |
| self.assertIn( |
| '</i> Mirroring in projects has been disabled in ' |
| 'this instance</div>', output_text) |
| |
| def test_new_project(self): |
| """ Test the new_project endpoint. """ |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'project#1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', 'project#1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', 'project#1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', 'project#1.git'))) |
| |
| user = tests.FakeUser() |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<strong>Create new Project</strong>', output_text) |
| |
| csrf_token = output_text.split( |
| 'name="csrf_token" type="hidden" value="')[1].split('">')[0] |
| |
| data = { |
| 'description': 'Project #1', |
| } |
| |
| output = self.app.post('/new/', data=data) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<strong>Create new Project</strong>', output_text) |
| self.assertIn( |
| '<small>\n This field is required. \n' |
| ' </small>', output_text) |
| |
| data['name'] = 'project-1' |
| output = self.app.post('/new/', data=data) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('<strong>Create new Project</strong>', output_text) |
| self.assertNotIn( |
| '<small>\n This field is required. \n' |
| ' </small>', output_text) |
| |
| data['csrf_token'] = csrf_token |
| output = self.app.post('/new/', data=data) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('<strong>Create new Project</strong>', output_text) |
| self.assertIn( |
| 'No user ' |
| '"username" found', |
| output_text) |
| |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| data['csrf_token'] = csrf_token |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<div class="projectinfo my-3">\nProject #1', |
| output_text) |
| self.assertIn('<p>This repo is brand new!</p>', |
| output_text) |
| self.assertIn( |
| '<title>Overview - project-1 - Pagure</title>', output_text) |
| |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 1) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'project-1.git'))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', 'project-1.git'))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', 'project-1.git'))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', 'project-1.git'))) |
| |
| @patch.dict('pagure.config.config', {'PAGURE_ADMIN_USERS': ['pingou'], |
| 'ALLOW_ADMIN_IGNORE_EXISTING_REPOS': True}) |
| def test_adopt_repos(self): |
| """ Test the new_project endpoint with existing git repo. """ |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| tests.create_projects_git(os.path.join(self.path, 'repos'), bare=True) |
| tests.add_content_git_repo(os.path.join(self.path, 'repos', 'test.git')) |
| |
| user = tests.FakeUser(username='pingou') |
| with tests.user_set(self.app.application, user): |
| data = { |
| 'csrf_token': self.get_csrf(), |
| 'name': 'test', |
| 'description': 'Project #1', |
| } |
| |
| 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('The main repo test.git 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("Alice Author", output_text) |
| |
| @patch.dict('pagure.config.config', {'PAGURE_ADMIN_USERS': [], |
| 'USERS_IGNORE_EXISTING_REPOS': ['pingou']}) |
| def test_adopt_repos_non_admin(self): |
| """ Test the new_project endpoint with existing git repo for non-admins. """ |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| tests.create_projects_git(os.path.join(self.path, 'repos'), bare=True) |
| tests.add_content_git_repo(os.path.join(self.path, 'repos', 'test.git')) |
| |
| user = tests.FakeUser(username='pingou') |
| with tests.user_set(self.app.application, user): |
| data = { |
| 'csrf_token': self.get_csrf(), |
| 'name': 'test', |
| 'description': 'Project #1', |
| } |
| |
| 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('The main repo test.git 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("Alice Author", output_text) |
| |
| @patch.dict('pagure.config.config', {'PAGURE_ADMIN_USERS': [], |
| 'USERS_IGNORE_EXISTING_REPOS': []}) |
| def test_adopt_repos_not_allowed(self): |
| """ Test the new_project endpoint with existing git repo for no access. """ |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| tests.create_projects_git(os.path.join(self.path, 'repos'), bare=True) |
| tests.add_content_git_repo(os.path.join(self.path, 'repos', 'test.git')) |
| |
| user = tests.FakeUser(username='pingou') |
| with tests.user_set(self.app.application, user): |
| data = { |
| 'csrf_token': self.get_csrf(), |
| 'name': 'test', |
| 'description': 'Project #1', |
| } |
| |
| 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('The main repo test.git 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('The main repo test.git already exists', output_text) |
| |
| @patch.dict('pagure.config.config', {'PROJECT_NAME_REGEX': '^1[a-z]*$'}) |
| def test_new_project_diff_regex(self): |
| """ Test the new_project endpoint with a different regex. """ |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| |
| user = tests.FakeUser(username='foo') |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<strong>Create new Project</strong>', output_text) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| data = { |
| 'description': 'Project #1', |
| 'name': 'project-1', |
| 'csrf_token': csrf_token, |
| } |
| |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>New project - Pagure</title>', output_text) |
| self.assertIn( |
| '<strong>Create new Project</strong>', output_text) |
| self.assertIn( |
| '<small>\n Invalid input. \n' |
| ' </small>', output_text) |
| |
| @patch.dict('pagure.config.config', {'PRIVATE_PROJECTS': True}) |
| def test_new_project_private(self): |
| """ Test the new_project endpoint for a private project. """ |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'foo', 'project#1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', 'foo', 'project#1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', 'foo', 'project#1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', 'foo', 'project#1.git'))) |
| |
| user = tests.FakeUser() |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/') |
| self.assertEqual(output.status_code, 200) |
| self.assertIn( |
| '<strong>Create new Project</strong>', output.get_data(as_text=True)) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| data = { |
| 'description': 'Project #1', |
| 'private': True, |
| } |
| |
| output = self.app.post('/new/', data=data) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<strong>Create new Project</strong>', output_text) |
| self.assertIn( |
| '<small>\n This field is required. \n' |
| ' </small>', output_text) |
| |
| data['name'] = 'project-1' |
| output = self.app.post('/new/', data=data) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('<strong>Create new Project</strong>', output_text) |
| self.assertNotIn( |
| '<small>\n This field is required. \n' |
| ' </small>', output_text) |
| |
| data['csrf_token'] = csrf_token |
| output = self.app.post('/new/', data=data) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('<strong>Create new Project</strong>', output_text) |
| self.assertIn( |
| 'No user ' |
| '"username" found', |
| output_text) |
| |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| data['csrf_token'] = csrf_token |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<div class="projectinfo my-3">\nProject #1', |
| output_text) |
| self.assertIn('<p>This repo is brand new!</p>', |
| output_text) |
| self.assertIn( |
| '<title>Overview - foo/project-1 - Pagure</title>', output_text) |
| |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| projects = pagure.lib.query.search_projects(self.session, private=True) |
| self.assertEqual(len(projects), 1) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'foo', 'project-1.git'))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', 'foo', 'project-1.git'))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', 'foo', 'project-1.git'))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', 'foo', 'project-1.git'))) |
| |
| def test_non_ascii_new_project(self): |
| """ Test the new_project endpoint with a non-ascii project. """ |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', 'project-1.git'))) |
| |
| user = tests.FakeUser() |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<strong>Create new Project</strong>', output_text) |
| |
| csrf_token = output_text.split( |
| 'name="csrf_token" type="hidden" value="')[1].split('">')[0] |
| |
| data = { |
| 'description': 'Prõjéctö #1', |
| 'name': 'project-1', |
| 'csrf_token': csrf_token, |
| 'create_readme': True, |
| } |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<div class="projectinfo my-3">\nPrõjéctö #1', |
| output_text) |
| self.assertIn( |
| '''<section class="readme"> |
| <h1>project-1</h1> |
| <p>Prõjéctö #1</p> |
| </section>''', |
| output_text) |
| |
| data = { |
| 'description': 'Мой первый суперский репозиторий', |
| 'name': 'project-2', |
| 'csrf_token': csrf_token, |
| 'create_readme': True, |
| } |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<div class="projectinfo my-3">\nМой первый суперский репозиторий', |
| output_text) |
| self.assertIn( |
| '''<section class="readme"> |
| <h1>project-2</h1> |
| <p>Мой первый суперский репозиторий</p> |
| </section>''', |
| output_text) |
| |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 2) |
| for project in ['project-1', 'project-2']: |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', '%s.git' % project))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', '%s.git' % project))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', '%s.git' % project))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', '%s.git' % project))) |
| |
| @patch('pygit2.init_repository', wraps=pygit2.init_repository) |
| def test_new_project_with_template(self, pygit2init): |
| """ Test the new_project endpoint for a new project with a template set. |
| """ |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', 'project-1.git'))) |
| |
| user = tests.FakeUser() |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/') |
| self.assertEqual(output.status_code, 200) |
| self.assertIn( |
| '<strong>Create new Project</strong>', output.get_data(as_text=True)) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| data = { |
| 'description': 'test', |
| 'name': 'project-1', |
| 'csrf_token': csrf_token, |
| 'create_readme': True, |
| } |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| self.assertIn( |
| '<div class="projectinfo my-3">\ntest', |
| output.get_data(as_text=True)) |
| |
| self.assertEqual(pygit2init.call_count, 4) |
| pygit2init.assert_any_call( |
| '%s/repos/project-1.git' % self.path, |
| bare=True, template_path=None) |
| |
| path = os.path.join(self.path, 'repos', 'project-1.git') |
| with patch.dict( |
| 'pagure.config.config', |
| {'PROJECT_TEMPLATE_PATH': path}): |
| data = { |
| 'description': 'test2', |
| 'name': 'project-2', |
| 'csrf_token': csrf_token, |
| 'create_readme': True, |
| } |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| self.assertIn( |
| '<div class="projectinfo my-3">\ntest2', |
| output.get_data(as_text=True)) |
| |
| self.assertEqual(pygit2init.call_count, 8) |
| pygit2init.assert_any_call( |
| '%s/repos/project-2.git' % self.path, |
| bare=True, |
| template_path='%s/repos/project-1.git' % self.path) |
| |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 2) |
| for project in ['project-1', 'project-2']: |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', '%s.git' % project))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', '%s.git' % project))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', '%s.git' % project))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', '%s.git' % project))) |
| |
| @patch.dict('pagure.config.config', {'CASE_SENSITIVE': True}) |
| def test_new_project_case_sensitive(self): |
| tests.create_projects(self.session) |
| tests.create_projects_git(os.path.join(self.path, 'repos'), bare=True) |
| |
| output = self.app.get('/test') |
| self.assertEqual(output.status_code, 200) |
| |
| output = self.app.get('/TEST') |
| self.assertEqual(output.status_code, 404) |
| |
| user = tests.FakeUser() |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/') |
| self.assertEqual(output.status_code, 200) |
| |
| csrf_token = self.get_csrf(output=output) |
| data = { |
| 'description': 'TEST', |
| 'name': 'TEST', |
| 'csrf_token': csrf_token, |
| 'create_readme': True, |
| } |
| self.app.post('/new/', data=data, follow_redirects=True) |
| |
| output = self.app.get('/TEST') |
| self.assertEqual(output.status_code, 200) |
| |
| @patch('pagure.ui.app.admin_session_timedout') |
| def test_user_settings(self, ast): |
| """ Test the user_settings endpoint. """ |
| ast.return_value = False |
| self.test_new_project() |
| |
| user = tests.FakeUser() |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/settings/') |
| self.assertEqual(output.status_code, 404) |
| self.assertIn('<h2>Page not found (404)</h2>', output.get_data(as_text=True)) |
| |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/settings/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>foo\'s settings - Pagure</title>', output_text) |
| |
| ast.return_value = True |
| output = self.app.get('/settings/') |
| self.assertEqual(output.status_code, 302) |
| |
| @patch('pagure.decorators.admin_session_timedout') |
| def test_add_user_sshkey(self, ast): |
| """ Test the add_user_sshkey endpoint. """ |
| ast.return_value = False |
| |
| |
| output = self.app.get('/settings/') |
| self.assertEqual(output.status_code, 302) |
| |
| ast.return_value = False |
| |
| user = tests.FakeUser(username='pingou') |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/settings', follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('<strong>Add SSH key', output_text) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| data = { |
| 'ssh_key': 'asdf', |
| } |
| |
| |
| output = self.app.post( |
| '/settings/usersettings/addkey', data=data , follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('<strong>Add SSH key', output_text) |
| |
| data['csrf_token'] = csrf_token |
| |
| |
| output = self.app.post( |
| '/settings/usersettings/addkey', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('<strong>Add SSH key', output_text) |
| self.assertIn('SSH key invalid', output_text) |
| |
| |
| data['ssh_key'] = 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDAzBMSIlvPRaEiLOTVInErkRIw9CzQQcnslDekAn1jFnGf+SNa1acvbTiATbCX71AA03giKrPxPH79dxcC7aDXerc6zRcKjJs6MAL9PrCjnbyxCKXRNNZU5U9X/DLaaL1b3caB+WD6OoorhS3LTEtKPX8xyjOzhf3OQSzNjhJp5Q==\nssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDAzBMSIlvPRaEiLOTVInErkRIw9CzQQcnslDekAn1jFnGf+SNa1acvbTiATbCX71AA03giKrPxPH79dxcC7aDXerc6zRcKjJs6MAL9PrCjnbyxCKXRNNZU5U9X/DLaaL1b3caB+WD6OoorhS3LTEtKPX8xyjOzhf3OQSzNjhJp5Q==' |
| output = self.app.post( |
| '/settings/usersettings/addkey', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('Please add single SSH keys.', output_text) |
| |
| |
| data['ssh_key'] = 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDAzBMSIlvPRaEiLOTVInErkRIw9CzQQcnslDekAn1jFnGf+SNa1acvbTiATbCX71AA03giKrPxPH79dxcC7aDXerc6zRcKjJs6MAL9PrCjnbyxCKXRNNZU5U9X/DLaaL1b3caB+WD6OoorhS3LTEtKPX8xyjOzhf3OQSzNjhJp5Q==' |
| output = self.app.post( |
| '/settings/usersettings/addkey', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| "<title>pingou's settings - Pagure</title>", output_text) |
| self.assertIn('SSH key added', output_text) |
| self.assertNotIn('Push Access', output_text) |
| |
| |
| output = self.app.post( |
| '/settings/usersettings/addkey', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('SSH key already exists', output_text) |
| |
| |
| data['ssh_key'] = 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQC9Xwc2RDzPBhlEDARfHldGjudIVoa04tqT1JVKGQmyllTFz7Rb8CngQL3e7zyNzotnhwYKHdoiLlPkVEiDee4dWMUe48ilqId+FJZQGhyv8fu4BoFdE1AJUVylzmltbLg14VqG5gjTpXgtlrEva9arKwBMHJjRYc8ScaSn3OgyQw==' |
| output = self.app.post( |
| '/settings/usersettings/addkey', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| "<title>pingou's settings - Pagure</title>", output_text) |
| self.assertIn('SSH key added', output_text) |
| |
| @patch('pagure.decorators.admin_session_timedout') |
| def test_remove_user_sshkey(self, ast): |
| """ Test the remove_sshkey endpoint. """ |
| ast.return_value = False |
| |
| user = tests.FakeUser() |
| |
| output = self.app.post('/settings/usersettings/removekey/1') |
| self.assertEqual(output.status_code, 302) |
| |
| user.username = 'pingou' |
| with tests.user_set(self.app.application, user): |
| data = {'csrf_token': self.get_csrf()} |
| |
| output = self.app.post( |
| '/settings/usersettings/removekey/1', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| "<title>pingou's settings - Pagure</title>", output_text) |
| self.assertIn('SSH key does not exist', output_text) |
| |
| |
| pingou = pagure.lib.query.get_user(self.session, 'pingou') |
| msg = pagure.lib.query.add_sshkey_to_project_or_user( |
| session=self.session, |
| ssh_key='ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDAzBMSIlvPRaEiLOTVInErkRIw9CzQQcnslDekAn1jFnGf+SNa1acvbTiATbCX71AA03giKrPxPH79dxcC7aDXerc6zRcKjJs6MAL9PrCjnbyxCKXRNNZU5U9X/DLaaL1b3caB+WD6OoorhS3LTEtKPX8xyjOzhf3OQSzNjhJp5Q==', |
| user=pingou, |
| pushaccess=True, |
| creator=pingou, |
| ) |
| self.session.commit() |
| self.assertEqual(msg, 'SSH key added') |
| |
| with tests.user_set(self.app.application, user): |
| output = self.app.post('/settings/usersettings/removekey/1', follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| "<title>pingou's settings - Pagure</title>", output_text) |
| self.assertNotIn('SSH key removed', output_text) |
| |
| data = {'csrf_token': self.get_csrf()} |
| output = self.app.post( |
| '/settings/usersettings/removekey/1', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| "<title>pingou's settings - Pagure</title>", output_text) |
| self.assertIn('SSH key removed', output_text) |
| |
| def patched_commit_exists(user, namespace, repo, githash): |
| ''' Patched version of pagure.pfmarkdown._commit_exists to enforce |
| returning true on some given hash without having us actually check |
| the git repos. |
| ''' |
| if githash in ['9364354', '9364354a', '9364354a4555ba17aa60f0dc844d70b74eb1aecd']: |
| return True |
| else: |
| return False |
| |
| @patch( |
| 'pagure.pfmarkdown._commit_exists', |
| MagicMock(side_effect=patched_commit_exists)) |
| def test_patched_markdown_preview(self): |
| """ Test the markdown_preview endpoint. """ |
| |
| data = { |
| 'content': 'test\n----\n\n * 1\n * item 2' |
| } |
| |
| |
| output = self.app.post('/markdown/', data=data) |
| self.assertEqual(output.status_code, 400) |
| |
| user = tests.FakeUser() |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/settings/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>foo\'s settings - Pagure</title>', output_text) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| |
| 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.get_data(as_text=True), exp) |
| |
| tests.create_projects(self.session) |
| texts = [ |
| 'pingou committed on test#9364354a4555ba17aa60f0dc844d70b74eb1aecd', |
| 'Cf commit 936435', |
| 'Cf commit 9364354', |
| 'Cf commit 9364354a', |
| 'Cf commit 9364354a4555ba17aa60f0dc844d70b74eb1aecd', |
| ] |
| expected = [ |
| |
| '<p>pingou committed on <a href="/test/c/9364354a4555ba17aa60f0dc844d70b74eb1aecd" ' |
| 'title="Commit 9364354a4555ba17aa60f0dc844d70b74eb1aecd"' |
| '>test#9364354a4555ba17aa60f0dc844d70b74eb1aecd</a></p>', |
| |
| '<p>Cf commit 936435</p>', |
| |
| |
| '<p>Cf commit <a href="/test/c/9364354" ' |
| 'title="Commit 9364354">9364354</a></p>', |
| |
| '<p>Cf commit <a href="/test/c/9364354a" ' |
| 'title="Commit 9364354a">9364354</a></p>', |
| |
| '<p>Cf commit <a href="/test/c/9364354a4555ba17aa60f0dc844d70b74eb1aecd" ' |
| 'title="Commit 9364354a4555ba17aa60f0dc844d70b74eb1aecd"' |
| '>9364354</a></p>', |
| ] |
| |
| with self.app.application.app_context(): |
| for idx, text in enumerate(texts): |
| data = { |
| 'content': text, |
| 'csrf_token': csrf_token, |
| } |
| output = self.app.post('/markdown/?repo=test', data=data) |
| self.assertEqual(output.status_code, 200) |
| self.assertEqual(expected[idx], output.get_data(as_text=True)) |
| |
| def test_markdown_preview(self): |
| """ Test the markdown_preview endpoint with a non-existing commit. |
| """ |
| |
| user = tests.FakeUser() |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/settings/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>foo\'s settings - Pagure</title>', output_text) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| tests.create_projects(self.session) |
| tests.create_projects_git(os.path.join(self.path, 'repos'), bare=True) |
| text = 'Cf commit 9364354a4555ba17aa60f0d' |
| exp = '<p>Cf commit 9364354a4555ba17aa60f0d</p>' |
| |
| with self.app.application.app_context(): |
| data = { |
| 'content': text, |
| 'csrf_token': csrf_token, |
| } |
| output = self.app.post('/markdown/?repo=test', data=data) |
| self.assertEqual(output.status_code, 200) |
| self.assertEqual(exp, output.get_data(as_text=True)) |
| |
| def test_markdown_preview_valid_commit(self): |
| """ Test the markdown_preview endpoint with an existing commit. """ |
| |
| user = tests.FakeUser() |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/settings/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>foo\'s settings - Pagure</title>', output_text) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| tests.create_projects(self.session) |
| tests.create_projects_git(os.path.join(self.path, 'repos'), bare=True) |
| repopath = os.path.join(self.path, 'repos', 'test.git') |
| tests.add_content_git_repo(repopath) |
| |
| repo = pygit2.Repository(repopath) |
| first_commit = repo.revparse_single('HEAD') |
| |
| text = 'Cf commit %s' % first_commit.oid.hex |
| exp = '<p>Cf commit <a href="/test/c/{0}" title="Commit {0}">{1}'\ |
| '</a></p>'.format(first_commit.oid.hex, first_commit.oid.hex[:7]) |
| |
| with self.app.application.app_context(): |
| data = { |
| 'content': text, |
| 'csrf_token': csrf_token, |
| } |
| output = self.app.post('/markdown/?repo=test', data=data) |
| self.assertEqual(output.status_code, 200) |
| self.assertEqual(exp, output.get_data(as_text=True)) |
| |
| @patch('pagure.ui.app.admin_session_timedout') |
| def test_remove_user_email(self, ast): |
| """ Test the remove_user_email endpoint. """ |
| ast.return_value = False |
| self.test_new_project() |
| |
| user = tests.FakeUser() |
| with tests.user_set(self.app.application, user): |
| output = self.app.post('/settings/email/drop') |
| self.assertEqual(output.status_code, 404) |
| self.assertIn('<h2>Page not found (404)</h2>', output.get_data(as_text=True)) |
| |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/settings/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>foo\'s settings - Pagure</title>', output_text) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| data = { |
| 'email': 'foo@pingou.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/drop', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>foo\'s settings - Pagure</title>', output_text) |
| self.assertIn( |
| 'You must always have at ' |
| 'least one email', output_text) |
| |
| user.username = 'pingou' |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/settings/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| data = { |
| 'email': 'foo@pingou.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/drop', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| self.assertEqual(output_text.count('foo@pingou.com'), 4) |
| |
| data = { |
| 'csrf_token': csrf_token, |
| 'email': 'foobar@pingou.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/drop', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| self.assertIn( |
| 'You do not have the ' |
| 'email: foobar@pingou.com, nothing to remove', output_text) |
| |
| data = { |
| 'csrf_token': csrf_token, |
| 'email': 'foo@pingou.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/drop', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertEqual(output_text.count('foo@pingou.com'), 0) |
| self.assertEqual(output_text.count('bar@pingou.com'), 3) |
| |
| output = self.app.post( |
| '/settings/email/drop', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertEqual(output_text.count('foo@pingou.com'), 0) |
| self.assertEqual(output_text.count('bar@pingou.com'), 3) |
| |
| ast.return_value = True |
| output = self.app.post('/settings/email/drop', data=data) |
| self.assertEqual(output.status_code, 302) |
| |
| @patch('pagure.lib.notify.send_email') |
| @patch('pagure.ui.app.admin_session_timedout') |
| def test_add_api_user_email(self, ast, send_email): |
| """ Test the add_api_user_email endpoint. """ |
| send_email.return_value = True |
| ast.return_value = False |
| self.test_new_project() |
| |
| user = tests.FakeUser() |
| with tests.user_set(self.app.application, user): |
| output = self.app.post('/settings/email/add') |
| self.assertEqual(output.status_code, 404) |
| self.assertIn('<h2>Page not found (404)</h2>', output.get_data(as_text=True)) |
| |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| output = self.app.post('/settings/email/add') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn("<strong>Add new email</strong>", output_text) |
| if self.get_wtforms_version() >= (2, 2): |
| self.assertIn( |
| '<input class="form-control form-control-error" id="email" ' |
| 'name="email" required type="text" value="">', output_text) |
| else: |
| self.assertIn( |
| '<input class="form-control form-control-error" id="email" ' |
| 'name="email" type="text" value="">', output_text) |
| |
| user.username = 'pingou' |
| with tests.user_set(self.app.application, user): |
| output = self.app.post('/settings/email/add') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn("<strong>Add new email</strong>", output_text) |
| if self.get_wtforms_version() >= (2, 2): |
| self.assertIn( |
| '<input class="form-control form-control-error" id="email" ' |
| 'name="email" required type="text" value="">', output_text) |
| else: |
| self.assertIn( |
| '<input class="form-control form-control-error" id="email" ' |
| 'name="email" type="text" value="">', output_text) |
| |
| csrf_token = output_text.split( |
| 'name="csrf_token" type="hidden" value="')[1].split('">')[0] |
| |
| data = { |
| 'email': 'foo2@pingou.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/add', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn("<strong>Add new email</strong>", output_text) |
| self.assertEqual(output_text.count('foo2@pingou.com'), 1) |
| |
| |
| data = { |
| 'csrf_token': csrf_token, |
| 'email': 'foðbar@pingou.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/add', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| self.assertIn( |
| 'Email pending validation', |
| output_text) |
| self.assertEqual(output_text.count('foo@pingou.com'), 4) |
| self.assertEqual(output_text.count('bar@pingou.com'), 5) |
| self.assertEqual(output_text.count('foðbar@pingou.com'), 2) |
| |
| |
| output = self.app.post( |
| '/settings/email/add', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<div class="card-header">\n ' |
| '<strong>Add new email</strong>', output_text) |
| self.assertIn( |
| 'This email is already ' |
| 'pending confirmation', output_text) |
| |
| |
| data = { |
| 'csrf_token': csrf_token, |
| 'email': 'foo@pingou.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/add', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertTrue("<strong>Add new email</strong>" in output_text) |
| self.assertTrue( |
| 'Invalid value, can't be any of: bar@pingou.com, ' |
| 'foo@pingou.com. ' in output_text |
| or |
| 'Invalid value, can't be any of: foo@pingou.com, ' |
| 'bar@pingou.com. ' in output_text |
| ) |
| self.assertEqual( |
| output_text.count('foo@pingou.com'), 6) |
| self.assertEqual( |
| output_text.count('bar@pingou.com'), 5) |
| self.assertEqual( |
| output_text.count('foðbar@pingou.com'), 0) |
| |
| |
| data = { |
| 'csrf_token': csrf_token, |
| 'email': 'foo@bar.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/add', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertTrue("<strong>Add new email</strong>" in output_text) |
| self.assertIn( |
| 'Invalid value, can't be any of: foo@bar.com. ', |
| output_text) |
| |
| ast.return_value = True |
| output = self.app.post('/settings/email/add', data=data) |
| self.assertEqual(output.status_code, 302) |
| |
| @patch('pagure.lib.notify.send_email') |
| @patch('pagure.ui.app.admin_session_timedout') |
| 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(self.app.application, user): |
| output = self.app.post('/settings/email/default') |
| self.assertEqual(output.status_code, 404) |
| self.assertTrue('<h2>Page not found (404)</h2>' in output.get_data(as_text=True)) |
| |
| user.username = 'pingou' |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/settings/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| data = { |
| 'email': 'foo@pingou.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/default', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| self.assertEqual(output_text.count('foo@pingou.com'), 4) |
| |
| |
| data = { |
| 'csrf_token': csrf_token, |
| 'email': 'foobar@pingou.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/default', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| self.assertEqual(output_text.count('foo@pingou.com'), 4) |
| self.assertIn( |
| 'You do not have the ' |
| 'email: foobar@pingou.com, nothing to set', |
| output_text) |
| |
| |
| data = { |
| 'csrf_token': csrf_token, |
| 'email': 'foo@pingou.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/default', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| self.assertEqual(output_text.count('foo@pingou.com'), 4) |
| self.assertIn( |
| 'Default email set to: ' |
| 'foo@pingou.com', output_text) |
| |
| ast.return_value = True |
| output = self.app.post('/settings/email/default', data=data) |
| self.assertEqual(output.status_code, 302) |
| |
| @patch('pagure.lib.notify.send_email') |
| @patch('pagure.ui.app.admin_session_timedout') |
| def test_reconfirm_email(self, ast, send_email): |
| """ Test the reconfirm_email endpoint. """ |
| send_email.return_value = True |
| ast.return_value = False |
| self.test_new_project() |
| |
| |
| userobj = pagure.lib.query.search_user(self.session, username='pingou') |
| |
| self.assertEqual(len(userobj.emails), 2) |
| |
| email_pend = pagure.lib.model.UserEmailPending( |
| user_id=userobj.id, |
| email='foo@fp.o', |
| token='abcdef', |
| ) |
| self.session.add(email_pend) |
| self.session.commit() |
| |
| user = tests.FakeUser() |
| with tests.user_set(self.app.application, user): |
| output = self.app.post('/settings/email/resend') |
| self.assertEqual(output.status_code, 404) |
| self.assertTrue('<h2>Page not found (404)</h2>' in output.get_data(as_text=True)) |
| |
| user.username = 'pingou' |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/settings/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| |
| csrf_token = self.get_csrf(output=output) |
| |
| data = { |
| 'email': 'foo@pingou.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/resend', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| self.assertEqual(output_text.count('foo@pingou.com'), 4) |
| |
| |
| data = { |
| 'csrf_token': csrf_token, |
| 'email': 'foobar@pingou.com', |
| } |
| |
| output = self.app.post( |
| '/settings/email/resend', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| self.assertEqual(output_text.count('foo@pingou.com'), 4) |
| self.assertIn( |
| 'This email address has ' |
| 'already been confirmed', output_text) |
| |
| |
| data = { |
| 'csrf_token': csrf_token, |
| 'email': 'foo@fp.o', |
| } |
| |
| output = self.app.post( |
| '/settings/email/resend', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| self.assertEqual(output_text.count('foo@pingou.com'), 4) |
| self.assertIn( |
| 'Confirmation email re-sent', |
| output_text) |
| |
| ast.return_value = True |
| output = self.app.post('/settings/email/resend', data=data) |
| self.assertEqual(output.status_code, 302) |
| |
| @patch('pagure.ui.app.admin_session_timedout') |
| def test_confirm_email(self, ast): |
| """ Test the confirm_email endpoint. """ |
| output = self.app.get('/settings/email/confirm/foobar') |
| self.assertEqual(output.status_code, 302) |
| |
| ast.return_value = False |
| |
| |
| userobj = pagure.lib.query.search_user(self.session, username='pingou') |
| |
| self.assertEqual(len(userobj.emails), 2) |
| |
| email_pend = pagure.lib.model.UserEmailPending( |
| user_id=userobj.id, |
| email='foo@fp.o', |
| token='abcdef', |
| ) |
| self.session.add(email_pend) |
| self.session.commit() |
| |
| user = tests.FakeUser() |
| user.username = 'pingou' |
| with tests.user_set(self.app.application, user): |
| |
| output = self.app.get( |
| '/settings/email/confirm/foobar', follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| self.assertIn( |
| 'No email associated with this token.', |
| output_text) |
| |
| |
| output = self.app.get( |
| '/settings/email/confirm/abcdef', follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>pingou\'s settings - Pagure</title>', output_text) |
| self.assertIn( |
| 'Email validated', |
| output_text) |
| |
| userobj = pagure.lib.query.search_user(self.session, username='pingou') |
| self.assertEqual(len(userobj.emails), 3) |
| |
| ast.return_value = True |
| output = self.app.get('/settings/email/confirm/foobar') |
| self.assertEqual(output.status_code, 302) |
| |
| |
| def test_view_my_requests_no_user(self): |
| """Test the view_user_requests endpoint.""" |
| output = self.app.get('/user/somenonexistentuser/requests') |
| self.assertEqual(output.status_code, 404) |
| |
| @patch( |
| 'pagure.lib.git.update_git', MagicMock(return_value=True)) |
| @patch( |
| 'pagure.lib.notify.send_email', MagicMock(return_value=True)) |
| def test_view_my_requests(self): |
| """Test the view_user_requests endpoint. """ |
| |
| tests.create_projects(self.session) |
| repo = pagure.lib.query._get_project(self.session, 'test') |
| req = pagure.lib.query.new_pull_request( |
| session=self.session, |
| repo_from=repo, |
| branch_from='dev', |
| repo_to=repo, |
| branch_to='master', |
| title='test pull-request #1', |
| user='pingou', |
| ) |
| self.session.commit() |
| self.assertEqual(req.id, 1) |
| self.assertEqual(req.title, 'test pull-request #1') |
| |
| output = self.app.get('/user/pingou/requests') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('test pull-request #1', output_text) |
| self.assertEqual( |
| output_text.count('pr-status pr-status-open"'), |
| 1) |
| |
| |
| item = pagure.lib.model.Project( |
| user_id=1, |
| name='test_fork', |
| description='test project #1', |
| is_fork=True, |
| parent_id=1, |
| hook_token='aaabbbttt', |
| ) |
| self.session.add(item) |
| repo = pagure.lib.query._get_project( |
| self.session, 'test_fork', user='pingou') |
| |
| req = pagure.lib.query.new_pull_request( |
| session=self.session, |
| repo_from=repo, |
| branch_from='dev', |
| repo_to=repo, |
| branch_to='master', |
| title='tést pull-request #2', |
| user='pingou', |
| ) |
| self.session.commit() |
| self.assertEqual(req.id, 1) |
| self.assertEqual(req.title, 'tést pull-request #2') |
| |
| output = self.app.get('/user/pingou/requests') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('test pull-request #1', output_text) |
| self.assertIn('tést pull-request #2', output_text) |
| self.assertEqual( |
| output_text.count('pr-status pr-status-open"'), |
| 2) |
| |
| @patch( |
| 'pagure.lib.git.update_git', MagicMock(return_value=True)) |
| @patch( |
| 'pagure.lib.notify.send_email', MagicMock(return_value=True)) |
| def test_view_my_requests_pr_in_another_project(self): |
| """Test the view_user_requests endpoint when the user opened a PR |
| in another project. """ |
| |
| tests.create_projects(self.session) |
| repo = pagure.lib.query._get_project(self.session, 'test') |
| req = pagure.lib.query.new_pull_request( |
| session=self.session, |
| repo_from=repo, |
| branch_from='dev', |
| repo_to=repo, |
| branch_to='master', |
| title='test pull-request #1', |
| user='pingou', |
| ) |
| self.session.commit() |
| self.assertEqual(req.id, 1) |
| self.assertEqual(req.title, 'test pull-request #1') |
| |
| |
| repo = pagure.lib.query._get_project(self.session, 'test') |
| req = pagure.lib.query.new_pull_request( |
| session=self.session, |
| repo_from=repo, |
| branch_from='dev', |
| repo_to=repo, |
| branch_to='master', |
| title='test pull-request #2', |
| user='foo', |
| ) |
| self.session.commit() |
| self.assertEqual(req.id, 2) |
| self.assertEqual(req.title, 'test pull-request #2') |
| |
| |
| output = self.app.get('/user/pingou/requests') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('test pull-request #1', output_text) |
| self.assertIn('test pull-request #2', output_text) |
| self.assertEqual( |
| output_text.count('pr-status pr-status-open"'), |
| 2) |
| |
| |
| output = self.app.get('/user/foo/requests') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertNotIn('test pull-request #1', output_text) |
| self.assertIn('test pull-request #2', output_text) |
| self.assertEqual( |
| output_text.count('pr-status pr-status-open"'), |
| 1) |
| |
| @patch( |
| 'pagure.lib.git.update_git', MagicMock(return_value=True)) |
| @patch( |
| 'pagure.lib.notify.send_email', MagicMock(return_value=True)) |
| def test_view_my_requests_against_another_project(self): |
| """Test the view_user_requests endpoint when there is a PR opened |
| by me against a project I do not have rights on. """ |
| |
| tests.create_projects(self.session) |
| repo = pagure.lib.query._get_project(self.session, 'test') |
| req = pagure.lib.query.new_pull_request( |
| session=self.session, |
| repo_from=repo, |
| branch_from='dev', |
| repo_to=repo, |
| branch_to='master', |
| title='test pull-request #1', |
| user='foo', |
| ) |
| self.session.commit() |
| self.assertEqual(req.id, 1) |
| self.assertEqual(req.title, 'test pull-request #1') |
| |
| output = self.app.get('/user/foo/requests') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('test pull-request #1', output_text) |
| self.assertEqual( |
| output_text.count('pr-status pr-status-open"'), |
| 1) |
| |
| def test_view_my_issues_no_user(self): |
| """Test the view_user_issues endpoint with a missing user.""" |
| output = self.app.get('/user/somenonexistentuser/issues') |
| self.assertEqual(output.status_code, 404) |
| |
| @patch( |
| 'pagure.lib.git.update_git', MagicMock(return_value=True)) |
| @patch( |
| 'pagure.lib.notify.send_email', MagicMock(return_value=True)) |
| def test_view_my_issues(self): |
| """Test the view_user_issues endpoint when the user exists.""" |
| |
| tests.create_projects(self.session) |
| repo = pagure.lib.query._get_project(self.session, 'test') |
| msg = pagure.lib.query.new_issue( |
| session=self.session, |
| repo=repo, |
| title='Test issue #1', |
| content='We should work on this for the second time', |
| user='pingou', |
| status='Open', |
| ) |
| self.session.commit() |
| self.assertEqual(msg.title, 'Test issue #1') |
| |
| output = self.app.get('/user/pingou/issues') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('Test issue #1', output_text) |
| self.assertEqual( |
| output_text.count( |
| 'issue-status issue-status-open'), |
| 1) |
| |
| |
| item = pagure.lib.model.Project( |
| user_id=2, |
| name='test_fork', |
| description='test project #1', |
| is_fork=True, |
| parent_id=1, |
| hook_token='aaabbbttt', |
| ) |
| self.session.add(item) |
| repo = pagure.lib.query._get_project(self.session, 'test_fork', user='foo') |
| |
| msg = pagure.lib.query.new_issue( |
| session=self.session, |
| repo=repo, |
| title='Test issue #2', |
| content='We should work on this for the second time', |
| user='pingou', |
| status='Open', |
| ) |
| self.session.commit() |
| self.assertEqual(msg.title, 'Test issue #2') |
| |
| |
| msg = pagure.lib.query.new_issue( |
| session=self.session, |
| repo=repo, |
| title='Test issue #3', |
| content='This issue created by foo, but assigned to pingou', |
| user='foo', |
| status='Open', |
| ) |
| self.session.commit() |
| self.assertEqual(msg.title, 'Test issue #3') |
| |
| msg = pagure.lib.query.add_issue_assignee( |
| session=self.session, |
| issue=msg, |
| assignee='pingou', |
| user='foo', |
| ) |
| self.session.commit() |
| self.assertEqual(msg, 'Issue assigned to pingou') |
| |
| output = self.app.get('/user/pingou/issues') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('Test issue #1', output_text) |
| self.assertIn('Test issue #2', output_text) |
| self.assertIn('Test issue #3', output_text) |
| self.assertEqual( |
| output_text.count( |
| 'issue-status issue-status-open'), |
| 3) |
| |
| @patch( |
| 'pagure.lib.git.update_git', MagicMock(return_value=True)) |
| @patch( |
| 'pagure.lib.notify.send_email', MagicMock(return_value=True)) |
| def test_view_my_issues_disabled(self): |
| """Test the view_user_issues endpoint when the project disabled issue |
| tracking.""" |
| |
| tests.create_projects(self.session) |
| repo = pagure.lib.query._get_project(self.session, 'test') |
| msg = pagure.lib.query.new_issue( |
| session=self.session, |
| repo=repo, |
| title='Test issue #1', |
| content='We should work on this for the second time', |
| user='pingou', |
| status='Open', |
| ) |
| self.session.commit() |
| self.assertEqual(msg.title, 'Test issue #1') |
| |
| |
| output = self.app.get('/user/pingou/issues') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('Test issue #1', output_text) |
| self.assertEqual( |
| output_text.count('issue-status issue-status-open'), |
| 1) |
| |
| |
| repo = pagure.lib.query._get_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('/user/pingou/issues') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertNotIn('Test issue #1', output_text) |
| self.assertEqual( |
| output_text.count('issue-status issue-status-open'), |
| 0) |
| |
| def test_view_my_issues_tickets_turned_off(self): |
| """Test the view_user_issues endpoint when the user exists and |
| and ENABLE_TICKETS is False """ |
| |
| |
| pagure.config.config['ENABLE_TICKETS'] = False |
| |
| output = self.app.get('/user/pingou/issues') |
| self.assertEqual(output.status_code, 404) |
| pagure.config.config['ENABLE_TICKETS'] = True |
| |
| @patch('pagure.ui.app.admin_session_timedout') |
| def test_add_user_token(self, ast): |
| """ Test the add_user_token endpoint. """ |
| ast.return_value = False |
| self.test_new_project() |
| |
| user = tests.FakeUser() |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/settings/token/new/') |
| self.assertEqual(output.status_code, 404) |
| self.assertIn('<h2>Page not found (404)</h2>', |
| output.get_data(as_text=True)) |
| |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/settings/token/new') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<div class="card-header">\n <strong>' |
| 'Create a new token</strong>\n', output_text) |
| self.assertIn( |
| '<input type="checkbox" name="acls" value="create_project">', |
| output_text) |
| |
| csrf_token = output_text.split( |
| 'name="csrf_token" type="hidden" value="')[1].split('">')[0] |
| |
| data = { |
| 'acls': ['create_project', 'fork_project'] |
| } |
| |
| |
| output = self.app.post('/settings/token/new', data=data) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>Create token - Pagure</title>', output_text) |
| self.assertIn( |
| '<div class="card-header">\n <strong>' |
| 'Create a new token</strong>\n', output_text) |
| self.assertIn( |
| '<input type="checkbox" name="acls" value="create_project">', |
| output_text) |
| |
| data = { |
| 'acls': ['new_project'], |
| 'csrf_token': csrf_token |
| } |
| |
| |
| output = self.app.post('/settings/token/new', data=data) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>Create token - Pagure</title>', output_text) |
| self.assertIn( |
| '<div class="card-header">\n <strong>' |
| 'Create a new token</strong>\n', output_text) |
| self.assertIn( |
| '<input type="checkbox" name="acls" value="create_project">', |
| output_text) |
| |
| data = { |
| 'acls': ['create_project', 'fork_project'], |
| 'csrf_token': csrf_token |
| } |
| |
| |
| output = self.app.post( |
| '/settings/token/new', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<title>foo\'s settings - Pagure</title>', output_text) |
| self.assertIn( |
| 'Token created', |
| output_text) |
| self.assertEqual( |
| output_text.count( |
| '<small class="font-weight-bold text-success input-group-text">Active until'), 1) |
| |
| ast.return_value = True |
| output = self.app.get('/settings/token/new') |
| self.assertEqual(output.status_code, 302) |
| |
| @patch('pagure.ui.app.admin_session_timedout') |
| def test_revoke_api_user_token(self, ast): |
| """ Test the revoke_api_user_token endpoint. """ |
| ast.return_value = False |
| self.test_new_project() |
| |
| user = tests.FakeUser() |
| with tests.user_set(self.app.application, user): |
| |
| output = self.app.post('/settings/token/revoke/foobar') |
| self.assertEqual(output.status_code, 404) |
| self.assertTrue('<h2>Page not found (404)</h2>' in output.get_data(as_text=True)) |
| |
| |
| item = pagure.lib.model.Token( |
| id='foobar', |
| user_id=2, |
| expiration=datetime.datetime.utcnow() \ |
| + datetime.timedelta(days=30) |
| ) |
| self.session.add(item) |
| self.session.commit() |
| |
| |
| output = self.app.post('/settings/token/revoke/foobar') |
| self.assertEqual(output.status_code, 404) |
| self.assertTrue('<h2>Page not found (404)</h2>' in output.get_data(as_text=True)) |
| |
| user.username = 'foo' |
| with tests.user_set(self.app.application, user): |
| |
| output = self.app.post( |
| '/settings/token/revoke/foobar', follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| "<title>foo's settings - Pagure</title>", output_text) |
| self.assertEqual( |
| output_text.count( |
| '<small class="font-weight-bold text-success input-group-text">Active until'), 1) |
| |
| csrf_token = output_text.split( |
| 'name="csrf_token" type="hidden" value="')[1].split('">')[0] |
| |
| data = { |
| 'csrf_token': csrf_token |
| } |
| |
| |
| output = self.app.post( |
| '/settings/token/revoke/foobar', data=data, |
| follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| "<title>foo's settings - Pagure</title>", output_text) |
| self.assertEqual( |
| output_text.count( |
| '<small class="font-weight-bold text-success input-group-text">Active until'), 0) |
| |
| user = pagure.lib.query.get_user(self.session, key='foo') |
| self.assertEqual(len(user.tokens), 1) |
| expiration_dt = user.tokens[0].expiration |
| |
| |
| output = self.app.post( |
| '/settings/token/revoke/foobar', data=data, |
| follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| "<title>foo's settings - Pagure</title>", output_text) |
| self.assertEqual( |
| output_text.count( |
| '<small class="font-weight-bold text-success input-group-text">Active until'), 0) |
| |
| |
| user = pagure.lib.query.get_user(self.session, key='foo') |
| self.assertEqual(len(user.tokens), 1) |
| self.assertEqual( |
| expiration_dt, user.tokens[0].expiration |
| ) |
| |
| ast.return_value = True |
| output = self.app.get('/settings/token/new') |
| self.assertEqual(output.status_code, 302) |
| |
| @patch.dict('pagure.config.config', {'PAGURE_AUTH': 'fas'}) |
| @patch.dict('pagure.utils.pagure_config', {'PAGURE_AUTH': 'fas'}) |
| def test_create_project_auth_FAS_no_FPCA(self): |
| """ Test creating a project when auth is FAS and the user did not |
| sign the FPCA. """ |
| |
| user = tests.FakeUser(username='foo', cla_done=False) |
| with tests.user_set(self.app.application, user): |
| output = self.app.get('/new/', follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('<title>Home - Pagure</title>', output_text) |
| self.assertIn( |
| '</i> You must <a href="https://admin.fedoraproject.org/accounts/' |
| '">sign the FPCA</a> (Fedora Project Contributor Agreement) ' |
| 'to use pagure</div>', output_text) |
| |
| |
| class PagureFlaskAppAboutPagetests(tests.Modeltests): |
| """ Unit-tests for the about page. """ |
| |
| def test_about_page(self): |
| """ Test the about page when an admin_email is set. """ |
| output = self.app.get('/about/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('<title>About - Pagure</title>', output_text) |
| self.assertIn( |
| 'by emailing:\n ' |
| '<a href="mailto:root@localhost.localdomain">', output_text) |
| self.assertIn( |
| 'href="https://pagure.io/pagure/issues">open a ticket</a>', |
| output_text) |
| |
| @patch.dict('pagure.config.config', {'ADMIN_EMAIL': 'admin@fp.o'}) |
| def test_about_page_admin_email(self): |
| """ Test the about page when an admin_email is set. """ |
| output = self.app.get('/about/') |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn('<title>About - Pagure</title>', output_text) |
| self.assertIn( |
| 'by emailing:\n <a href="mailto:admin@fp.o">', |
| output_text) |
| self.assertIn( |
| 'href="https://pagure.io/pagure/issues">open a ticket</a>', |
| output_text) |
| |
| |
| class PagureFlaskAppNoDocstests(tests.Modeltests): |
| """ Tests for flask app controller of pagure """ |
| |
| config_values = { |
| "enable_docs": False, |
| "docs_folder": None, |
| } |
| |
| def test_new_project_no_docs_folder(self): |
| """ Test the new_project endpoint with DOCS_FOLDER is None. """ |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'project#1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', 'project#1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', 'project#1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', 'project#1.git'))) |
| |
| user = tests.FakeUser(username='foo') |
| with tests.user_set(self.app.application, user): |
| |
| csrf_token = self.get_csrf() |
| |
| data = { |
| 'description': 'Project #1', |
| 'name': 'project-1', |
| 'csrf_token': csrf_token, |
| } |
| |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<div class="projectinfo my-3">\nProject #1', |
| output_text) |
| self.assertIn('<p>This repo is brand new!</p>', |
| output_text) |
| self.assertIn( |
| '<title>Overview - project-1 - Pagure</title>', output_text) |
| |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 1) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'project-1.git'))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', 'project-1.git'))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', 'project-1.git'))) |
| |
| |
| class PagureFlaskAppNoTicketstests(tests.Modeltests): |
| """ Tests for flask app controller of pagure """ |
| |
| config_values = { |
| "enable_tickets": False, |
| "tickets_folder": None, |
| } |
| |
| def test_new_project_no_tickets_folder(self): |
| """ Test the new_project endpoint with TICKETS_FOLDER is None. """ |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 0) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'project#1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', 'project#1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', 'project#1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', 'project#1.git'))) |
| |
| user = tests.FakeUser(username='foo') |
| with tests.user_set(self.app.application, user): |
| |
| csrf_token = self.get_csrf() |
| |
| data = { |
| 'description': 'Project #1', |
| 'name': 'project-1', |
| 'csrf_token': csrf_token, |
| } |
| |
| output = self.app.post('/new/', data=data, follow_redirects=True) |
| self.assertEqual(output.status_code, 200) |
| output_text = output.get_data(as_text=True) |
| self.assertIn( |
| '<div class="projectinfo my-3">\nProject #1', |
| output_text) |
| self.assertIn('<p>This repo is brand new!</p>', |
| output_text) |
| self.assertIn( |
| '<title>Overview - project-1 - Pagure</title>', output_text) |
| |
| |
| projects = pagure.lib.query.search_projects(self.session) |
| self.assertEqual(len(projects), 1) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'project-1.git'))) |
| self.assertFalse(os.path.exists( |
| os.path.join(self.path, 'repos', 'tickets', 'project-1.git'))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'docs', 'project-1.git'))) |
| self.assertTrue(os.path.exists( |
| os.path.join(self.path, 'repos', 'requests', 'project-1.git'))) |
| |
| |
| if __name__ == '__main__': |
| unittest.main(verbosity=2) |