def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiProjectBlockuserTests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
item = pagure.lib.model.Token(
id="aaabbbcccdddeee",
user_id=2,
project_id=1,
expiration=datetime.datetime.utcnow()
+ datetime.timedelta(days=30),
)
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id="aaabbbcccdddeee")
project = pagure.lib.query.get_authorized_project(self.session, "test")
self.assertEqual(project.block_users, [])
self.blocked_users = []
project = pagure.lib.query.get_authorized_project(
self.session, "test2"
)
project.block_users = ["foo"]
self.session.add(project)
self.session.commit()
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiProjectUpdateWatchTests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "tickets"))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create normal 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 #1",
content="We should work on this",
user="******",
private=False,
)
self.session.commit()
self.assertEqual(msg.title, "Test issue #1")
# Create project-less token for user foo
item = pagure.lib.model.Token(
id="project-less-foo",
user_id=1,
project_id=None,
expiration=datetime.datetime.utcnow()
+ datetime.timedelta(days=30),
)
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id="project-less-foo")
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskQuickReplytest, self).setUp()
pagure.APP.config['TESTING'] = True
pagure.SESSION = self.session
pagure.ui.app.SESSION = self.session
pagure.ui.filters.SESSION = self.session
pagure.ui.fork.SESSION = self.session
pagure.ui.issues.SESSION = self.session
pagure.ui.plugins.SESSION = self.session
pagure.ui.repo.SESSION = self.session
pagure.ui.SESSION = self.session
pagure.APP.config['GIT_FOLDER'] = self.path
pagure.APP.config['TICKETS_FOLDER'] = os.path.join(
self.path, 'tickets')
pagure.APP.config['DOCS_FOLDER'] = os.path.join(
self.path, 'docs')
self.app = pagure.APP.test_client()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path), bare=True)
self.admin = tests.FakeUser(username='******')
self.user = tests.FakeUser(username='******')
self.repo = pagure.lib.get_project(self.session, 'test')
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiIssueCreatetests, self).setUp()
pagure.config.config["TICKETS_FOLDER"] = None
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "tickets"))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create project-less token for user foo
item = pagure.lib.model.Token(
id="project-less-foo",
user_id=2,
project_id=None,
expiration=datetime.datetime.utcnow()
+ datetime.timedelta(days=30),
)
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id="project-less-foo")
# Create project-specific token for user foo
item = pagure.lib.model.Token(
id="project-specific-foo",
user_id=2,
project_id=1,
expiration=datetime.datetime.utcnow()
+ datetime.timedelta(days=30),
)
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id="project-specific-foo")
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 setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskPluginPagureHooktests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"))
tests.create_projects_git(os.path.join(self.path, "repos", "docs"))
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureExcludeGroupIndex, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
# Create a ``provenpackger`` group:
msg = pagure.lib.query.add_group(
self.session,
group_name="provenpackager",
display_name="Proven Packagers",
description="Packagers having access to all the repo",
group_type="user",
user="******",
is_admin=False,
blacklist=[],
)
self.session.commit()
self.assertEqual(
msg, "User `pingou` added to the group `provenpackager`."
)
# Add the `provenpackager` group to the test2 project
project = pagure.lib.query._get_project(self.session, "test2")
msg = pagure.lib.query.add_group_to_project(
session=self.session,
project=project,
new_group="provenpackager",
user="******",
)
self.session.commit()
self.assertEqual(msg, "Group added")
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 setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureGetRemoteRepoPath, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
tests.add_content_git_repo(
os.path.join(self.path, "repos", "test2.git")
)
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskQuickReplytest, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
self.admin = tests.FakeUser(username="******")
self.user = tests.FakeUser(username="******")
self.repo = pagure.lib.query._get_project(self.session, "test")
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureGetRemoteRepoPath, self).setUp()
pagure.APP.config['GIT_FOLDER'] = os.path.join(self.path, 'repos')
pagure.APP.config['REMOTE_GIT_FOLDER'] = os.path.join(
self.path, 'remotes')
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'repos'), bare=True)
tests.add_content_git_repo(os.path.join(self.path, 'repos', 'test2.git'))
def test_plugin_default_ui(self):
""" Test the default hook 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/default')
self.assertEqual(output.status_code, 403)
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskPluginPagureNoNewBranchHooktests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"))
pagure.config.config["GIT_FOLDER"] = os.path.join(self.path, "repos")
with tests.user_set(self.app.application, tests.FakeUser()):
self.csrf_token = self.get_csrf()
def test_mirror_project(self, rgl):
""" Test the mirror_project method. """
rgl.return_value = ("stdout", "stderr")
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
# before
self.assertEqual(
sorted(os.listdir(self.sshkeydir)), ["test", "test.pub"]
)
project = pagure.lib.query.get_authorized_project(self.session, "test")
self.assertIsNotNone(project.mirror_hook.public_key)
self.assertTrue(project.mirror_hook.public_key.startswith("ssh-rsa "))
pagure.lib.tasks_mirror.mirror_project(
username=None, namespace=None, name="test"
)
# after
self.assertEqual(
sorted(os.listdir(self.sshkeydir)), ["test", "test.pub"]
)
project = pagure.lib.query.get_authorized_project(self.session, "test")
self.assertIsNotNone(project.mirror_hook.public_key)
self.assertTrue(project.mirror_hook.public_key.startswith("ssh-rsa "))
ssh_script = os.path.abspath(
os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"..",
"pagure",
"lib",
"ssh_script.sh",
)
)
calls = [
call(
[
"push",
"--mirror",
"ssh://[email protected]/foobar.git",
],
abspath=os.path.join(self.path, "repos", "test.git"),
env={
"GIT_SSH": ssh_script,
"SSHKEY": "%s/sshkeys/test" % self.path,
},
error=True,
)
]
self.assertEqual(rgl.call_count, 1)
self.assertEqual(calls, rgl.mock_calls)
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskGiveRepotests, self).setUp()
pagure.config.config["VIRUS_SCAN_ATTACHMENTS"] = False
pagure.config.config["UPLOAD_FOLDER_URL"] = "/releases/"
pagure.config.config["UPLOAD_FOLDER_PATH"] = os.path.join(
self.path, "releases"
)
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
self._check_user(user="******")
def test_view_commit_old_with_bogus_url(self):
""" Test the view_commit_old endpoint. """
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
# Add a README to the git repo - First commit
tests.add_readme_git_repo(os.path.join(self.path, "repos", "test.git"))
pygit2.Repository(os.path.join(self.path, "repos", "test.git"))
# View first commit
output = self.app.get("/apple-touch-icon-152x152-precomposed.png")
self.assertEqual(output.status_code, 404)
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(self.path, "repos"), bare=True)
user = tests.FakeUser()
user.username = "******"
with tests.user_set(self.app.application, user):
# Get the CSRF token
output = self.app.get("/test/settings")
output_text = output.get_data(as_text=True)
csrf_token = output_text.split(
'name="csrf_token" type="hidden" value="'
)[1].split('">')[0]
data = {
"milestones": [1, 2],
"milestone_1_name": "v1.0",
"milestone_2_name": "v2.0",
"milestone_1_date": "",
"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": None},
"v2.0": {"active": False, "date": None},
},
)
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureLibGitMirrorProjecttests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
# Make the test project mirrored from elsewhere
self.project = pagure.lib.query.get_authorized_project(
self.session, "test"
)
self.project.mirrored_from = "https://example.com/foo/bar.git"
self.session.add(self.project)
self.session.commit()
def test_api_new_issue(self):
""" Test the api_new_issue method of the flask api. """
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(tests.HERE, "tickets"))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {"Authorization": "token aaabbbcccddd"}
# Valid token, wrong project
output = self.app.post("/api/0/test2/new_issue", headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit "
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK",
},
)
# No input
output = self.app.post("/api/0/test/new_issue", headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(data, {"error": "Invalid or incomplete input submited", "error_code": "EINVALIDREQ"})
data = {"title": "test issue"}
# Invalid repo
output = self.app.post("/api/0/foo/new_issue", data=data, headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(data, {"error": "Project not found", "error_code": "ENOPROJECT"})
# Incomplete request
output = self.app.post("/api/0/test/new_issue", data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(data, {"error": "Invalid or incomplete input submited", "error_code": "EINVALIDREQ"})
data = {"title": "test issue", "issue_content": "This issue needs attention"}
# Valid request
output = self.app.post("/api/0/test/new_issue", data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(data, {"message": "Issue created"})
def test_ticket_with_priorities(self, p_send_email, p_ugt):
""" Test creating a ticket with priorities. """
p_send_email.return_value = True
p_ugt.return_value = True
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(tests.HERE), bare=True)
# Set some priorities
repo = pagure.lib.get_project(self.session, 'test')
repo.priorities = {'1': 'High', '2': 'Normal'}
self.session.add(repo)
self.session.commit()
user = tests.FakeUser()
user.username = '******'
with tests.user_set(pagure.APP, user):
# Get the CSRF token
output = self.app.get('/test/new_issue')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<div class="card-header">\n New issue'
in output.data)
csrf_token = output.data.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)
self.assertIn(
'<title>Issue #1: Test issue - test - Pagure</title>',
output.data)
self.assertIn(
'<a class="btn btn-primary btn-sm" '
'href="/test/issue/1/edit" title="Edit this issue">',
output.data)
self.assertIn('<div id="priority_plain">', output.data)
self.assertIn('<option value="1">High</option>', output.data)
def test_api_new_project_user_ns(self, p_gga):
""" Test the api_new_project method of the flask api. """
pagure.APP.config['USER_NAMESPACE'] = True
p_gga.return_value = True
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'tickets'))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token aaabbbcccddd'}
# Create a project with the user namespace feature on
data = {
'name': 'testproject',
'description': 'Just another small test project',
}
# Valid request
output = self.app.post(
'/api/0/new/', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Project "pingou/testproject" created'}
)
# Create a project with a namespace and the user namespace feature on
pagure.APP.config['ALLOWED_PREFIX'] = ['testns']
data = {
'name': 'testproject2',
'namespace': 'testns',
'description': 'Just another small test project',
}
# Valid request
output = self.app.post(
'/api/0/new/', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Project "testns/testproject2" created'}
)
pagure.APP.config['USER_NAMESPACE'] = False
def test_ticket_with_no_roadmap(self, p_send_email, p_ugt):
""" Test creating a ticket without 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)
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,
)
def test_view_docs_project_no_docs(self):
""" Test the view_docs endpoint with a project that disabled the
docs.
"""
tests.create_projects(self.session)
repo = pagure.lib.query.get_authorized_project(self.session, "test")
tests.create_projects_git(os.path.join(self.path, "repos", "docs"))
output = self.app.get("/test/docs")
self.assertEqual(output.status_code, 404)
repo.settings = {"project_documentation": False}
self.session.add(repo)
self.session.commit()
output = self.app.get("/test/docs", follow_redirects=True)
self.assertEqual(output.status_code, 404)
def test_new_remote_no_title(self):
""" Test creating a new remote PR authenticated when no title is
specified. """
tests.create_projects(self.session)
tests.create_projects_git(
os.path.join(self.path, "requests"), bare=True
)
self.set_up_git_repo()
# Before
self.session = pagure.lib.query.create_session(self.dbpath)
project = pagure.lib.query.get_authorized_project(self.session, "test")
self.assertEqual(len(project.requests), 0)
# Try creating a remote PR
user = tests.FakeUser(username="******")
with tests.user_set(self.app.application, user):
output = self.app.get("/test/diff/remote")
self.assertEqual(output.status_code, 200)
self.assertIn(
"<h2>New remote pull-request</h2>",
output.get_data(as_text=True),
)
csrf_token = self.get_csrf(output=output)
with patch(
"pagure.forms.RemoteRequestPullForm.git_repo.args",
MagicMock(
return_value=(
"Git Repo address",
[wtforms.validators.DataRequired()],
)
),
):
data = {
"csrf_token": csrf_token,
"branch_from": "master",
"branch_to": "feature",
"git_repo": os.path.join(self.newpath, "test"),
}
output = self.app.post("/test/diff/remote", data=data)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn("<h2>New remote pull-request</h2>", output_text)
self.assertIn("<option selected>feature</option>", output_text)
def test_view_docs_project_no_docs(self):
""" Test the view_docs endpoint with a project that disabled the
docs.
"""
tests.create_projects(self.session)
repo = pagure.lib.get_project(self.session, 'test')
tests.create_projects_git(os.path.join(tests.HERE, 'docs'))
output = self.app.get('/test/docs')
self.assertEqual(output.status_code, 404)
repo.settings = {'project_documentation': False}
self.session.add(repo)
self.session.commit()
output = self.app.get('/test/docs', follow_redirects=True)
self.assertEqual(output.status_code, 404)
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskRepoMilestonestests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"))
repo = pagure.lib.query.get_authorized_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="******",
status="Open",
)
self.session.commit()
self.assertEqual(msg.title, "Test issue #1")
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskIssuesPrivatetests, self).setUp()
# Create a 3rd user
item = pagure.lib.model.User(
user="******",
fullname="Random user",
password="******",
default_email="*****@*****.**",
)
self.session.add(item)
item = pagure.lib.model.UserEmail(user_id=3, email="*****@*****.**")
self.session.add(item)
self.session.commit()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"))
repo = pagure.lib.query.get_authorized_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="******",
status="Open",
private=True,
)
self.session.commit()
self.assertEqual(msg.title, "Test issue #1")
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="******",
status="Open",
private=False,
)
self.session.commit()
self.assertEqual(msg.title, "Test issue #2")
def test_view_docs_project_no_docs(self):
""" Test the view_docs endpoint with a project that disabled the
docs.
"""
tests.create_projects(self.session)
repo = pagure.lib.get_project(self.session, 'test')
tests.create_projects_git(os.path.join(tests.HERE, 'docs'))
output = self.app.get('/test/docs')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h2>Docs</h2>' in output.data)
self.assertTrue('<p>This repo is brand new!</p>' in output.data)
self.assertTrue(
'git clone [email protected]:docs/test.git' in output.data)
repo.settings = {'project_documentation': False}
self.session.add(repo)
self.session.commit()
output = self.app.get('/test/docs', follow_redirects=True)
self.assertEqual(output.status_code, 404)
def setUp(self):
""" Set up the environnment, run before every tests. """
super(PagureFlaskIssuesTemplatetests, self).setUp()
pagure.config.config["TICKETS_FOLDER"] = os.path.join(
self.path, "tickets"
)
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
tests.create_projects_git(os.path.join(self.path, "tickets"))
# Add a couple of templates to test2
repopath = os.path.join(self.path, "tickets", "test2.git")
create_templates(repopath)
# Add a couple of templates to somenamespace/test3
repopath = os.path.join(
self.path, "tickets", "somenamespace", "test3.git"
)
create_templates(repopath)
def setUp(self):
""" Set up the environnment, run before every tests. """
super(PagureUtilsTests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'repos'), bare=True)
tests.add_content_git_repo(os.path.join(self.path, 'repos', 'test2.git'))
project = pagure.lib.query._get_project(self.session, 'test')
# Add a deploy key to the project
new_key_obj = pagure.lib.model.SSHKey(
project_id=project.id,
pushaccess=False,
public_ssh_key='\n foo bar',
ssh_short_key='\n foo bar',
ssh_search_key='\n foo bar',
creator_user_id=1 # pingou
)
self.session.add(new_key_obj)
self.session.commit()
def test_new_remote_pr_unauth(self):
""" Test creating a new remote PR un-authenticated. """
tests.create_projects(self.session)
tests.create_projects_git(
os.path.join(self.path, "requests"), bare=True
)
self.set_up_git_repo()
# Before
project = pagure.lib.query.get_authorized_project(self.session, "test")
self.assertEqual(len(project.requests), 0)
# Try creating a remote PR
output = self.app.get("/test/diff/remote")
self.assertEqual(output.status_code, 302)
self.assertIn(
"You should be redirected automatically to target URL: "
'<a href="/login/?',
output.get_data(as_text=True),
)
def setUp(self):
""" Set up the environment, ran before every tests. """
super(PagureFlaskRepoViewHistoryFiletests, self).setUp()
self.regex = re.compile(r' <div class="list-group-item " id="c_')
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
# Add some content to the git repo
tests.add_content_to_git(
os.path.join(self.path, "repos", "test.git"),
message="initial commit",
)
tests.add_content_to_git(os.path.join(self.path, "repos", "test.git"),
message="foo")
tests.add_content_to_git(
os.path.join(self.path, "repos", "test.git"),
branch="feature",
content="bar",
message="bar",
author=("Aritz Author", "*****@*****.**"),
)
def test_view_docs_project_no_docs(self):
""" Test the view_docs endpoint with a project that disabled the
docs.
"""
tests.create_projects(self.session)
repo = pagure.lib.get_project(self.session, 'test')
tests.create_projects_git(os.path.join(tests.HERE, 'docs'))
output = self.app.get('/test/docs')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h2>Docs</h2>' in output.data)
self.assertTrue('<p>This repo is brand new!</p>' in output.data)
self.assertTrue(
'git clone [email protected]:docs/test.git' in output.data)
repo.settings = {'project_documentation': False}
self.session.add(repo)
self.session.commit()
output = self.app.get('/test/docs', follow_redirects=True)
self.assertEqual(output.status_code, 404)
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskDeleteRepotests, self).setUp()
# Create some projects
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'repos'))
self.session.commit()
# Create all the git repos
tests.create_projects_git(os.path.join(self.path, 'repos'))
tests.create_projects_git(os.path.join(self.path, 'repos', 'docs'))
tests.create_projects_git(
os.path.join(self.path, 'repos', 'tickets'), bare=True)
tests.create_projects_git(
os.path.join(self.path, 'repos', 'requests'), bare=True)
project = pagure.lib.get_authorized_project(
self.session, project_name='test')
self.assertIsNotNone(project)
# Ensure the project isn't read-only
project.read_only = False
self.session.add(project)
self.session.commit()
# Create a fork
task = pagure.lib.fork_project(
session=self.session,
user='******',
repo=project,
gitfolder=os.path.join(self.path, 'repos'),
docfolder=os.path.join(self.path, 'repos', 'docs'),
ticketfolder=os.path.join(self.path, 'repos', 'tickets'),
requestfolder=os.path.join(self.path, 'repos', 'requests'),
)
task.get()
# Ensure everything was correctly created
projects = pagure.lib.search_projects(self.session)
self.assertEqual(len(projects), 4)
def test_get_git_tags_objects(self):
""" Test the get_git_tags_objects method of pagure.lib.git. """
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'repos'), bare=True)
project = pagure.lib.query._get_project(self.session, 'test')
# Case 1 - Empty repo with no tags
exp = []
tags = pagure.lib.git.get_git_tags_objects(project)
self.assertEqual(exp, get_tag_name(tags))
tests.add_readme_git_repo(os.path.join(os.path.join(
self.path, 'repos'), 'test.git'))
repo = pygit2.Repository(os.path.join(os.path.join(
self.path, 'repos'), 'test.git'))
# Case 2 - Repo with one commit and no tags
exp = []
tags = pagure.lib.git.get_git_tags_objects(project)
self.assertEqual(exp, get_tag_name(tags))
# Case 3 - Simple sort
exp = ['0.1.0', 'test-0.0.21', '0.0.12-beta', '0.0.12-alpha', '0.0.12',
'0.0.11', '0.0.3', 'foo-0.0.2', '0.0.1']
add_repo_tag(self.path, repo, exp, 'test.git')
tags = pagure.lib.git.get_git_tags_objects(project)
self.assertEqual(exp, get_tag_name(tags))
# Case 4 - Sorting with different splitting characters
project = pagure.lib.query.get_authorized_project(self.session, 'test2')
tests.add_readme_git_repo(os.path.join(os.path.join(
self.path, 'repos'), 'test2.git'))
repo = pygit2.Repository(os.path.join(os.path.join(
self.path, 'repos'), 'test2.git'))
exp = ['1.0-0_2', '1.0-0_1', '0.1-1_0', '0.1-0_0', '0.0-2_0',
'0.0-1_34', '0.0-1_11', '0.0-1_3', '0.0-1_2', '0.0-1_1']
add_repo_tag(self.path, repo, exp, 'test2.git')
tags = pagure.lib.git.get_git_tags_objects(project)
self.assertEqual(exp, get_tag_name(tags))
def test_ticket_with_no_roadmap(self, p_send_email, p_ugt):
""" Test creating a ticket without roadmap. """
p_send_email.return_value = True
p_ugt.return_value = True
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/new_issue')
self.assertEqual(output.status_code, 200)
self.assertTrue(
u'<div class="card-header">\n New issue' in output.data)
csrf_token = output.data.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)
self.assertIn(
u'<title>Issue #1: Test issue - test - Pagure</title>',
output.data)
self.assertIn(
u'<a class="btn btn-primary btn-sm" '
'href="/test/issue/1/edit" title="Edit this issue">',
output.data)
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskIssuesAndPRDisabledtests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'repos'))
# Make the project's issue tracker read-only
repo = pagure.lib.query.get_authorized_project(self.session, 'test')
settings = repo.settings
settings['pull_requests'] = False
settings['issue_tracker_read_only'] = True
repo.settings = settings
self.session.add(repo)
self.session.commit()
# Create a couple of issue
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='******',
status='Open',
private=True,
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue #1')
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='******',
status='Open',
private=False,
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue #2')
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskIssuesAndPRDisabledtests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"))
# Make the project's issue tracker read-only
repo = pagure.lib.query.get_authorized_project(self.session, "test")
settings = repo.settings
settings["pull_requests"] = False
settings["issue_tracker_read_only"] = True
repo.settings = settings
self.session.add(repo)
self.session.commit()
# Create a couple of issue
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="******",
status="Open",
private=True,
)
self.session.commit()
self.assertEqual(msg.title, "Test issue #1")
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="******",
status="Open",
private=False,
)
self.session.commit()
self.assertEqual(msg.title, "Test issue #2")
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskUiArchivesTest, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
project = pagure.lib.query._get_project(self.session, "test")
# test has both commits and tags
repopath = os.path.join(self.path, "repos", "test.git")
tests.add_readme_git_repo(repopath)
repo = pygit2.Repository(repopath)
add_repo_tag(self.path, repo, ["v1.0", "v1.1"], "test.git")
# test2 has only commits
tests.add_readme_git_repo(os.path.join(self.path, "repos",
"test2.git"))
# somenamespace/test3 has neither commits nor tags
# Create the archive folder:
self.archive_path = os.path.join(self.path, "archives")
os.mkdir(self.archive_path)
def test_new_remote_no_title(self):
""" Test creating a new remote PR authenticated when no title is
specified. """
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'requests'),
bare=True)
self.set_up_git_repo()
# Before
self.session = pagure.lib.query.create_session(self.dbpath)
project = pagure.lib.query.get_authorized_project(self.session, 'test')
self.assertEqual(len(project.requests), 0)
# Try creating a remote PR
user = tests.FakeUser(username='******')
with tests.user_set(self.app.application, user):
output = self.app.get('/test/diff/remote')
self.assertEqual(output.status_code, 200)
self.assertIn('<h2>New remote pull-request</h2>',
output.get_data(as_text=True))
csrf_token = self.get_csrf(output=output)
with patch(
'pagure.forms.RemoteRequestPullForm.git_repo.args',
MagicMock(
return_value=(u'Git Repo address',
[wtforms.validators.DataRequired()]))):
data = {
'csrf_token': csrf_token,
'branch_from': 'master',
'branch_to': 'feature',
'git_repo': os.path.join(self.newpath, 'test'),
}
output = self.app.post('/test/diff/remote', data=data)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn('<h2>New remote pull-request</h2>', output_text)
self.assertIn('<option selected>feature</option>', output_text)
def test_has_settings(self):
""" Test that user can see the Settings button when they are logged
in. """
# Create a local user
self.test_new_user()
self.session.commit()
# Remove the token
item = pagure.lib.query.search_user(self.session, username='******')
item.token = None
self.session.add(item)
self.session.commit()
# Check the user
item = pagure.lib.query.search_user(self.session, username='******')
self.assertEqual(item.user, 'foouser')
self.assertEqual(item.token, None)
# Add a test project to the user
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'repos'))
output = self.app.get('/test')
output_text = output.get_data(as_text=True)
self.assertEqual(output.status_code, 200)
self.assertIn(
'<title>Overview - test - Pagure</title>', output_text)
# Login and redirect to the test project
user = tests.FakeUser(username='******')
with tests.user_set(self.app.application, user):
output = self.app.get('/test')
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn(
'<title>Overview - test - Pagure</title>', output_text)
self.assertIn(
'<span class="d-none d-md-inline">Settings</span>',
output_text)
def setUp(self):
""" Set up the environnment, ran before every tests. """
self.maxDiff = None
super(PagureFlaskApiCustomFieldIssuetests, self).setUp()
pagure.config.config['TICKETS_FOLDER'] = None
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'tickets'))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create normal issue
repo = pagure.lib.query.get_authorized_project(self.session, 'test')
pagure.lib.query.new_issue(
session=self.session,
repo=repo,
title='Test issue #1',
content='We should work on this',
user='******',
private=False,
)
self.session.commit()
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskPrNoSourcestests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
# Create foo's fork of pingou's test project
item = pagure.lib.model.Project(
user_id=2, # foo
name="test",
description="test project #1",
hook_token="aaabbb",
is_fork=True,
parent_id=1,
)
self.session.add(item)
self.session.commit()
# Create the fork's git repo
repo_path = os.path.join(self.path, "repos", item.path)
pygit2.init_repository(repo_path, bare=True)
project = pagure.lib.query.get_authorized_project(self.session, "test")
fork = pagure.lib.query.get_authorized_project(self.session,
"test",
user="******")
self.set_up_git_repo(repo=project, fork=fork)
# Ensure things got setup straight
project = pagure.lib.query.get_authorized_project(self.session, "test")
self.assertEqual(len(project.requests), 1)
# wait for the worker to process the task
path = os.path.join(self.path, "repos", "test.git", "refs", "pull",
"1", "head")
self.assertTrue(os.path.exists(path))
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskRepoViewFileForktests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(
os.path.join(self.path, 'repos'), bare=True)
# Add some content to the git repo
tests.add_content_git_repo(
os.path.join(self.path, 'repos', 'test.git'))
tests.add_readme_git_repo(
os.path.join(self.path, 'repos', 'test.git'))
tests.add_binary_git_repo(
os.path.join(self.path, 'repos', 'test.git'), 'test.jpg')
tests.add_binary_git_repo(
os.path.join(self.path, 'repos', 'test.git'), 'test_binary')
# Add a fork of a fork
item = pagure.lib.model.Project(
user_id=1, # pingou
name='test',
description='test project #3',
is_fork=True,
parent_id=1,
hook_token='aaabbbppp',
)
self.session.add(item)
self.session.commit()
tests.add_content_git_repo(
os.path.join(self.path, 'repos', 'forks', 'pingou', 'test.git'))
tests.add_readme_git_repo(
os.path.join(self.path, 'repos', 'forks', 'pingou', 'test.git'))
tests.add_commit_git_repo(
os.path.join(self.path, 'repos', 'forks', 'pingou', 'test.git'),
ncommits=10)
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiIssueCreatetests, self).setUp()
pagure.APP.config['TESTING'] = True
pagure.SESSION = self.session
pagure.api.SESSION = self.session
pagure.api.issue.SESSION = self.session
pagure.lib.SESSION = self.session
pagure.APP.config['TICKETS_FOLDER'] = None
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'tickets'))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create project-less token for user foo
item = pagure.lib.model.Token(id='project-less-foo',
user_id=2,
project_id=None,
expiration=datetime.datetime.utcnow() +
datetime.timedelta(days=30))
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id='project-less-foo')
# Create project-specific token for user foo
item = pagure.lib.model.Token(id='project-specific-foo',
user_id=2,
project_id=1,
expiration=datetime.datetime.utcnow() +
datetime.timedelta(days=30))
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id='project-specific-foo')
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)
self.assertIn('Projects <span class="label label-default">0</span>',
output.data)
self.assertIn('Forks <span class="label label-default">0</span>',
output.data)
tests.create_projects(self.session)
self.gitrepos = tests.create_projects_git(
pagure.APP.config['GIT_FOLDER'])
output = self.app.get('/user/pingou?repopage=abc&forkpage=def')
self.assertEqual(output.status_code, 200)
self.assertIn('Projects <span class="label label-default">2</span>',
output.data)
self.assertIn('Forks <span class="label label-default">0</span>',
output.data)
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)
self.assertTrue(
'<section class="project_list" id="repos">' in output.data)
self.assertTrue('<h2>Projects (0)</h2>' in output.data)
self.assertTrue(
'<section class="project_list" id="forks">' in output.data)
self.assertTrue('<h2>Forks (0)</h2>' in output.data)
tests.create_projects(self.session)
self.gitrepos = tests.create_projects_git(
pagure.APP.config['GIT_FOLDER'])
output = self.app.get('/user/pingou?repopage=abc&forkpage=def')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<section class="project_list" id="repos">' in output.data)
self.assertTrue('<h2>Projects (2)</h2>' in output.data)
self.assertTrue(
'<section class="project_list" id="forks">' in output.data)
self.assertTrue('<h2>Forks (0)</h2>' in output.data)
def test_api_change_status_issue(self):
""" Test the api_change_status_issue method of the flask api. """
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(tests.HERE, 'tickets'))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token aaabbbcccddd'}
# Invalid project
output = self.app.post('/api/0/foo/issue/1/status', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Project not found",
"error_code": "ENOPROJECT",
}
)
# Valid token, wrong project
output = self.app.post('/api/0/test2/issue/1/status', headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit " \
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK",
}
)
# No input
output = self.app.post('/api/0/test/issue/1/status', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Issue not found",
"error_code": "ENOISSUE",
}
)
# Create normal issue
repo = pagure.lib.get_project(self.session, 'test')
msg = pagure.lib.new_issue(
session=self.session,
repo=repo,
title='Test issue #1',
content='We should work on this',
user='******',
ticketfolder=None,
private=False,
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue #1')
# Create another project
item = pagure.lib.model.Project(
user_id=2, # pingou
name='foo',
description='test project #3',
hook_token='aaabbbdddeee',
)
self.session.add(item)
self.session.commit()
# Create a token for pingou for this project
item = pagure.lib.model.Token(
id='pingou_foo',
user_id=1,
project_id=3,
expiration=datetime.datetime.utcnow() + datetime.timedelta(
days=30)
)
self.session.add(item)
self.session.commit()
# Give `change_status_issue` to this token
item = pagure.lib.model.TokenAcl(
token_id='pingou_foo',
acl_id=6,
)
self.session.add(item)
self.session.commit()
repo = pagure.lib.get_project(self.session, 'foo')
# Create private issue
msg = pagure.lib.new_issue(
session=self.session,
repo=repo,
title='Test issue',
content='We should work on this',
user='******',
ticketfolder=None,
private=True,
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue')
# Check status before
repo = pagure.lib.get_project(self.session, 'test')
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(issue.status, 'Open')
data = {
'title': 'test issue',
}
# Incomplete request
output = self.app.post(
'/api/0/test/issue/1/status', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
}
)
# No change
repo = pagure.lib.get_project(self.session, 'test')
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(issue.status, 'Open')
data = {
'status': 'Open',
}
# Valid request but no change
output = self.app.post(
'/api/0/test/issue/1/status', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'No changes'}
)
# No change
repo = pagure.lib.get_project(self.session, 'test')
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(issue.status, 'Open')
data = {
'status': 'Fixed',
}
# Valid request
output = self.app.post(
'/api/0/test/issue/1/status', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Successfully edited issue #1'}
)
headers = {'Authorization': 'token pingou_foo'}
# Un-authorized issue
output = self.app.post(
'/api/0/foo/issue/1/status', data=data, headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please "
"visit https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK"
}
)
def test_api_new_issue(self):
""" Test the api_new_issue method of the flask api. """
tests.create_projects(self.session)
tests.create_projects_git(
os.path.join(tests.HERE, 'tickets'), bare=True)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token aaabbbcccddd'}
# Valid token, wrong project
output = self.app.post('/api/0/test2/new_issue', headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit " \
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK",
}
)
# No input
output = self.app.post('/api/0/test/new_issue', headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
}
)
data = {
'title': 'test issue',
}
# Invalid repo
output = self.app.post(
'/api/0/foo/new_issue', data=data, headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Project not found",
"error_code": "ENOPROJECT",
}
)
# Incomplete request
output = self.app.post(
'/api/0/test/new_issue', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
}
)
data = {
'title': 'test issue',
'issue_content': 'This issue needs attention',
}
# Valid request
output = self.app.post(
'/api/0/test/new_issue', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Issue created'}
)
def test_plugin_unsigned(self):
""" Test the noff 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/Block Un-Signed commits')
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>Block Un-Signed commits settings</h3>',
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/Block Un-Signed commits', 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>Block Un-Signed commits settings</h3>',
output.data)
self.assertTrue(
'<input id="active" name="active" type="checkbox" value="y">'
in output.data)
data['csrf_token'] = csrf_token
# With the git repo
output = self.app.post(
'/test/settings/Block Un-Signed commits',
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 Block Un-Signed '
'commits deactivated' in output.data)
output = self.app.get(
'/test/settings/Block Un-Signed commits')
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>Block Un-Signed commits settings</h3>',
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, 'repos', 'test.git', 'hooks',
'pre-receive.pagureunsignedcommit')))
# Activate the hook
data = {'csrf_token': csrf_token, 'active': 'y'}
output = self.app.post(
'/test/settings/Block Un-Signed commits',
data=data, follow_redirects=True)
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(
'<section class="settings">\n <h3>Settings for test</h3>',
output.data)
self.assertNotIn(
'</button>\n Hook activated',
output.data)
self.assertTrue(os.path.exists(os.path.join(
self.path, 'repos', 'test.git', 'hooks',
'pre-receive.pagureunsignedcommit')))
# De-Activate hook
data = {'csrf_token': csrf_token}
output = self.app.post(
'/test/settings/Block Un-Signed commits',
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 Block Un-Signed '
'commits deactivated' in output.data)
output = self.app.get(
'/test/settings/Block Un-Signed commits')
self.assertIn(
'<div class="projectinfo m-t-1 m-b-1">\n'
'test project #1 </div>', output.data)
self.assertIn(
'<h3>Block Un-Signed commits 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',
'pre-receive.pagureunsignedcommit')))
def test_plugin_mail(self):
""" Test the irc 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/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(tests.HERE, 'test.git', 'hooks',
'post-receive.irc')))
data['csrf_token'] = csrf_token
# No git found
output = self.app.post('/test/settings/IRC', data=data)
self.assertEqual(output.status_code, 404)
tests.create_projects_git(tests.HERE)
# 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(tests.HERE, '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(
#tests.HERE, '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(tests.HERE, 'test.git', 'hooks',
'post-receive.irc')))
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureRebaseNotAllowedtests, self).setUp()
pagure.config.config["REQUESTS_FOLDER"] = None
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
tests.create_projects_git(
os.path.join(self.path, "requests"), bare=True
)
tests.add_content_to_git(
os.path.join(self.path, "repos", "test.git"),
branch="master",
content="foobarbaz",
filename="testfile",
)
project = pagure.lib.query.get_authorized_project(self.session, "test")
# Fork the project
task = pagure.lib.query.fork_project(
session=self.session, user="******", repo=project
)
self.session.commit()
self.assertEqual(
task.get(),
{
"endpoint": "ui_ns.view_repo",
"repo": "test",
"username": "******",
"namespace": None,
},
)
tests.add_content_to_git(
os.path.join(self.path, "repos", "forks", "foo", "test.git"),
branch="test",
content="foobar",
filename="sources",
)
fork_repo = pagure.lib.query.get_authorized_project(
self.session, "test", user="******"
)
tests.add_readme_git_repo(os.path.join(self.path, "repos", "test.git"))
# Create a PR for these changes
project = pagure.lib.query.get_authorized_project(self.session, "test")
req = pagure.lib.query.new_pull_request(
session=self.session,
repo_from=fork_repo,
branch_from="test",
repo_to=project,
branch_to="master",
title="PR from the test branch",
user="******",
allow_rebase=False,
)
self.session.commit()
self.assertEqual(req.id, 1)
self.assertEqual(req.title, "PR from the test branch")
self.project = pagure.lib.query.get_authorized_project(
self.session, "test"
)
self.assertEqual(len(project.requests), 1)
self.request = self.project.requests[0]
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(self.app.application, user):
output = self.app.get('/test/settings/Pagure requests')
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>Pagure requests settings</h3>' in output.data)
self.assertTrue(
'<input class="form-control" 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/Pagure requests', 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>Pagure requests settings</h3>' in output.data)
self.assertTrue(
'<input class="form-control" id="active" name="active" '
'type="checkbox" value="y">' in output.data)
data['csrf_token'] = csrf_token
# Create the requests repo
tests.create_projects_git(
os.path.join(self.path, 'repos', 'requests'))
output = self.app.post('/test/settings/Pagure requests',
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 Pagure requests deactivated'
in output.data)
output = self.app.get('/test/settings/Pagure requests')
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>Pagure requests settings</h3>' in output.data)
self.assertTrue(
'<input class="form-control" id="active" name="active" '
'type="checkbox" value="y">' in 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',
}
output = self.app.post('/test/settings/Pagure requests',
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 Pagure requests activated'
in output.data)
output = self.app.get('/test/settings/Pagure requests')
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>Pagure requests settings</h3>' in output.data)
self.assertTrue(
'<input checked class="form-control" id="active" name="active" '
'type="checkbox" value="y">' in output.data)
self.assertTrue(
os.path.exists(
os.path.join(self.path, 'repos', 'requests', 'test.git',
'hooks', 'post-receive.pagure-requests')))
# De-Activate hook
data = {'csrf_token': csrf_token}
output = self.app.post('/test/settings/Pagure requests',
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 Pagure requests deactivated'
in output.data)
output = self.app.get('/test/settings/Pagure requests')
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>Pagure requests settings</h3>' in output.data)
self.assertTrue(
'<input class="form-control" id="active" name="active" '
'type="checkbox" value="y">' in output.data)
self.assertFalse(
os.path.exists(
os.path.join(self.path, 'requests', 'test.git', 'hooks',
'post-receive.pagure-requests')))
# Try re-activate hook w/o the git repo
data = {
'csrf_token': csrf_token,
'active': 'y',
}
shutil.rmtree(
os.path.join(self.path, 'repos', 'requests', 'test.git'))
output = self.app.post('/test/settings/Pagure requests', data=data)
self.assertEqual(output.status_code, 404)
def test_plugin_pagure_ci(self):
""" Test the pagure ci plugin on/off endpoint. """
tests.create_projects(self.session)
tests.create_projects_git(tests.HERE)
user = tests.FakeUser(username='******')
with tests.user_set(pagure.APP, user):
output = self.app.get('/test/settings/Pagure CI')
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>Pagure CI settings</h3>' in output.data)
self.assertIn(
'<td><label for="ci_url">URL to the project on the CI '
'service</label></td>' , 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/Pagure CI', 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>Pagure CI settings</h3>' in output.data)
self.assertIn(
'<td><label for="ci_url">URL to the project on the CI '
'service</label></td>' , output.data)
self.assertIn(
'<input id="active" name="active" type="checkbox" value="y">',
output.data)
# Activate hook
data = {
'active': 'y',
'ci_url': 'https://jenkins.fedoraproject.org',
'ci_type': 'jenkins',
}
# CSRF Token missing
output = self.app.post(
'/test/settings/Pagure CI', data=data, follow_redirects=True)
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>Pagure CI settings</h3>' in output.data)
self.assertIn(
'<td><label for="ci_url">URL to the project on the CI '
'service</label></td>' , output.data)
self.assertIn(
'<input checked id="active" name="active" type="checkbox" '
'value="y">', output.data)
data['csrf_token'] = csrf_token
if not pagure.APP.config.get('PAGURE_CI_SERVICES'):
return
# Activate hook
output = self.app.post(
'/test/settings/Pagure CI', data=data, follow_redirects=True)
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(
'<title>Settings - test - Pagure</title>', output.data)
self.assertIn('<h3>Settings for test</h3>', output.data)
self.assertIn(
'</button>\n Hook Pagure CI activated',
output.data)
output = self.app.get('/test/settings/Pagure CI')
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>Pagure CI settings</h3>' in output.data)
self.assertIn(
'<td><label for="ci_url">URL to the project on the CI '
'service</label></td>' , output.data)
self.assertTrue(
'<input checked id="active" name="active" type="checkbox" value="y">'
in output.data)
# De-activate the hook
data = {
'csrf_token': csrf_token,
}
output = self.app.post(
'/test/settings/Pagure CI', data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertIn(
'</button>\n Hook Pagure CI inactived',
output.data)
self.assertIn(
'<section class="settings">\n <h3>Settings for test</h3>',
output.data)
output = self.app.get('/test/settings/Pagure CI')
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>Pagure CI settings</h3>' in output.data)
self.assertIn(
'<td><label for="ci_url">URL to the project on the CI '
'service</label></td>' , output.data)
self.assertIn(
'<input id="active" name="active" type="checkbox" '
'value="y">', output.data)
# Missing the required ci_url
data = {'csrf_token': csrf_token, 'active': 'y'}
output = self.app.post(
'/test/settings/Pagure CI', data=data, follow_redirects=True)
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>Pagure CI settings</h3>', output.data)
self.assertFalse(
'</button>\n Hook activated' in output.data)
self.assertIn(
'<td><input id="ci_url" name="ci_url" type="text" value="">'
'</td>\n<td class="errors">This field is required.</td>',
output.data)
self.assertIn(
'<input checked id="active" name="active" type="checkbox" '
'value="y">', output.data)
def test_update_request_from_git(self):
""" Test the update_request_from_git method from pagure.lib.git. """
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(tests.HERE, 'repos'))
repo = pagure.lib.get_project(self.session, 'test')
# Before
self.assertEqual(len(repo.requests), 0)
self.assertEqual(repo.requests, [])
data = {
"status": True,
"uid": "d4182a2ac2d541d884742d3037c26e56",
"project": {
"parent": None,
"settings": {
"issue_tracker": True,
"project_documentation": True,
"pull_requests": True,
},
"name": "test",
"date_created": "1426500194",
"tags": [],
"user": {
"fullname": "Pierre-YvesChibon",
"name": "pingou",
"default_email": "*****@*****.**",
"emails": [
"*****@*****.**"
]
},
"id": 1,
"description": "test project"
},
"commit_stop": "eface8e13bc2a08a3fb22af9a72a8c90e36b8b89",
"user": {
"fullname": "Pierre-YvesChibon",
"name": "pingou",
"default_email": "*****@*****.**",
"emails": ["*****@*****.**"]
},
"id": 7,
"comments": [
{
"comment": "really?",
"user": {
"fullname": "Pierre-YvesChibon",
"name": "pingou",
"default_email": "*****@*****.**",
"emails": ["*****@*****.**"]
},
"parent": None,
"date_created": "1426843778",
"commit": "fa72f315373ec5f98f2b08c8ffae3645c97aaad2",
"line": 5,
"id": 1,
"filename": "test"
},
{
"comment": "Again ?",
"user": {
"fullname": "Pierre-YvesChibon",
"name": "pingou",
"default_email": "*****@*****.**",
"emails": [
"*****@*****.**"
]
},
"parent": None,
"date_created": "1426866781",
"commit": "94ebaf900161394059478fd88aec30e59092a1d7",
"line": 5,
"id": 2,
"filename": "test2"
},
{
"comment": "Should be fine in fact",
"user": {
"fullname": "Pierre-YvesChibon",
"name": "pingou",
"default_email": "*****@*****.**",
"emails": [
"*****@*****.**"
]
},
"parent": None,
"date_created": "1426866950",
"commit": "94ebaf900161394059478fd88aec30e59092a1d7",
"line": 5,
"id": 3,
"filename": "test2"
}
],
"branch_from": "master",
"title": "test request",
"commit_start": "788efeaaf86bde8618f594a8181abb402e1dd904",
"repo_from": {
"parent": {
"parent": None,
"name": "test",
"date_created": "1426500194",
"tags": [],
"user": {
"fullname": "Pierre-YvesChibon",
"name": "pingou",
"default_email": "*****@*****.**",
"emails": [
"*****@*****.**"
]
},
"settings": {
"issue_tracker": True,
"project_documentation": True,
"pull_requests": True,
},
"id": 1,
"description": "test project"
},
"settings": {
"issue_tracker": True,
"project_documentation": True,
"pull_requests": True,
},
"name": "test",
"date_created": "1426843440",
"tags": [],
"user": {
"fullname": "fake user",
"name": "fake",
"default_email": "*****@*****.**",
"emails": [
"*****@*****.**"
]
},
"id": 6,
"description": "test project"
},
"branch": "master",
"date_created": "1426843732"
}
self.assertRaises(
pagure.exceptions.PagureException,
pagure.lib.git.update_request_from_git,
self.session,
reponame='foobar',
username=None,
request_uid='d4182a2ac2d541d884742d3037c26e56',
json_data=data,
gitfolder=tests.HERE,
docfolder=os.path.join(tests.HERE, 'docs'),
ticketfolder=os.path.join(tests.HERE, 'tickets'),
requestfolder=os.path.join(tests.HERE, 'requests')
)
pagure.lib.git.update_request_from_git(
self.session,
reponame='test',
username=None,
request_uid='d4182a2ac2d541d884742d3037c26e56',
json_data=data,
gitfolder=tests.HERE,
docfolder=os.path.join(tests.HERE, 'docs'),
ticketfolder=os.path.join(tests.HERE, 'tickets'),
requestfolder=os.path.join(tests.HERE, 'requests')
)
self.session.commit()
# After 1 st insertion
self.assertEqual(len(repo.requests), 1)
self.assertEqual(repo.requests[0].id, 7)
self.assertEqual(
repo.requests[0].uid, 'd4182a2ac2d541d884742d3037c26e56')
self.assertEqual(repo.requests[0].title, 'test request')
self.assertEqual(len(repo.requests[0].comments), 3)
data = {
"status": True,
"uid": "d4182a2ac2d541d884742d3037c26e57",
"project": {
"parent": None,
"name": "test",
"date_created": "1426500194",
"tags": [],
"user": {
"fullname": "Pierre-YvesChibon",
"name": "pingou",
"default_email": "*****@*****.**",
"emails": [
"*****@*****.**"
]
},
"settings": {
"issue_tracker": True,
"project_documentation": True,
"pull_requests": True,
},
"id": 1,
"description": "test project"
},
"commit_stop": "eface8e13bc2a08a3fb22af9a72a8c90e36b8b89",
"user": {
"fullname": "Pierre-YvesChibon",
"name": "pingou",
"default_email": "*****@*****.**",
"emails": ["*****@*****.**"]
},
"id": 4,
"comments": [],
"branch_from": "master",
"title": "test request #2",
"commit_start": "788efeaaf86bde8618f594a8181abb402e1dd904",
"repo_from": {
"parent": {
"parent": None,
"name": "test",
"date_created": "1426500194",
"tags": [],
"user": {
"fullname": "Pierre-YvesChibon",
"name": "pingou",
"default_email": "*****@*****.**",
"emails": [
"*****@*****.**"
]
},
"settings": {
"issue_tracker": True,
"project_documentation": True,
"pull_requests": True,
},
"id": 1,
"description": "test project"
},
"settings": {
"issue_tracker": True,
"project_documentation": True,
"pull_requests": True,
},
"name": "test",
"date_created": "1426843440",
"tags": [],
"user": {
"fullname": "fake user",
"name": "fake",
"default_email": "*****@*****.**",
"emails": [
"*****@*****.**"
]
},
"project_docs": True,
"id": 6,
"description": "test project"
},
"branch": "master",
"date_created": "1426843745"
}
pagure.lib.git.update_request_from_git(
self.session,
reponame='test',
username=None,
request_uid='d4182a2ac2d541d884742d3037c26e57',
json_data=data,
gitfolder=tests.HERE,
docfolder=os.path.join(tests.HERE, 'docs'),
ticketfolder=os.path.join(tests.HERE, 'tickets'),
requestfolder=os.path.join(tests.HERE, 'requests')
)
self.session.commit()
# After 2 nd insertion
self.assertEqual(len(repo.requests), 2)
self.assertEqual(repo.requests[0].id, 7)
self.assertEqual(
repo.requests[0].uid, 'd4182a2ac2d541d884742d3037c26e56')
self.assertEqual(repo.requests[0].title, 'test request')
self.assertEqual(len(repo.requests[0].comments), 3)
# 2 entry
self.assertEqual(repo.requests[1].id, 4)
self.assertEqual(
repo.requests[1].uid, 'd4182a2ac2d541d884742d3037c26e57')
self.assertEqual(repo.requests[1].title, 'test request #2')
self.assertEqual(len(repo.requests[1].comments), 0)
def test_view_commit_old(self):
""" Test the view_commit_old endpoint. """
tests.create_projects(self.session)
tests.create_projects_git(self.path, bare=True)
# Add a README to the git repo - First commit
tests.add_readme_git_repo(os.path.join(self.path, 'test.git'))
repo = pygit2.Repository(os.path.join(self.path, 'test.git'))
commit = repo.revparse_single('HEAD')
# View first commit
output = self.app.get('/test/%s' % commit.oid.hex)
self.assertEqual(output.status_code, 302)
output = self.app.get('/test/%s' % commit.oid.hex,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<div class="list-group" id="diff_list" style="display:none;">' in
output.data)
self.assertTrue(' Authored by Alice Author\n' in output.data)
self.assertTrue(' Committed by Cecil Committer\n' in output.data)
self.assertTrue(
'<span style="color: #00A000">+ Pagure</span>' in output.data)
self.assertTrue(
'<span style="color: #00A000">+ ======</span>' in output.data)
self.app = pagure.APP.test_client()
# View first commit - with the old URL scheme
output = self.app.get('/test/%s' % commit.oid.hex,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<div class="list-group" id="diff_list" style="display:none;">' in
output.data)
self.assertTrue(' Authored by Alice Author\n' in output.data)
self.assertTrue(' Committed by Cecil Committer\n' in output.data)
self.assertTrue(
'<span style="color: #00A000">+ Pagure</span>' in output.data)
self.assertTrue(
'<span style="color: #00A000">+ ======</span>' in output.data)
# Add some content to the git repo
tests.add_content_git_repo(os.path.join(self.path, 'test.git'))
repo = pygit2.Repository(os.path.join(self.path, 'test.git'))
commit = repo.revparse_single('HEAD')
# View another commit
output = self.app.get('/test/%s' % commit.oid.hex,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<div class="list-group" id="diff_list" style="display:none;">' in
output.data)
self.assertTrue(' Authored by Alice Author\n' in output.data)
self.assertTrue(' Committed by Cecil Committer\n' in output.data)
self.assertTrue(
# new version of pygments
'<div class="highlight" style="background: #f8f8f8">'
'<pre style="line-height: 125%">'
'<span></span>'
'<span style="color: #800080; font-weight: bold">'
'@@ -0,0 +1,3 @@</span>' in output.data or
# old version of pygments
'<div class="highlight" style="background: #f8f8f8">'
'<pre style="line-height: 125%">'
'<span style="color: #800080; font-weight: bold">'
'@@ -0,0 +1,3 @@</span>' in output.data)
# Add a fork of a fork
item = pagure.lib.model.Project(
user_id=1, # pingou
name='test3',
description='test project #3',
is_fork=True,
parent_id=1,
hook_token='aaabbbkkk',
)
self.session.add(item)
self.session.commit()
forkedgit = os.path.join(self.path, 'forks', 'pingou', 'test3.git')
tests.add_content_git_repo(forkedgit)
tests.add_readme_git_repo(forkedgit)
repo = pygit2.Repository(forkedgit)
commit = repo.revparse_single('HEAD')
# Commit does not exist in anothe repo :)
output = self.app.get('/test/%s' % commit.oid.hex,
follow_redirects=True)
self.assertEqual(output.status_code, 404)
# View commit of fork
output = self.app.get('/fork/pingou/test3/%s' % commit.oid.hex,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<div class="list-group" id="diff_list" style="display:none;">' in
output.data)
self.assertTrue(' Authored by Alice Author\n' in output.data)
self.assertTrue(' Committed by Cecil Committer\n' in output.data)
self.assertTrue(
'<span style="color: #00A000">+ Pagure</span>' in output.data)
self.assertTrue(
'<span style="color: #00A000">+ ======</span>' in output.data)
# View commit of fork - With the old URL scheme
output = self.app.get('/fork/pingou/test3/%s' % commit.oid.hex,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<div class="list-group" id="diff_list" style="display:none;">' in
output.data)
self.assertTrue(' Authored by Alice Author\n' in output.data)
self.assertTrue(' Committed by Cecil Committer\n' in output.data)
self.assertTrue(
'<span style="color: #00A000">+ Pagure</span>' in output.data)
self.assertTrue(
'<span style="color: #00A000">+ ======</span>' in output.data)
# Try the old URL scheme with a short hash
output = self.app.get('/fork/pingou/test3/%s' % commit.oid.hex[:10],
follow_redirects=True)
self.assertEqual(output.status_code, 404)
self.assertIn('<p>Project not found</p>', 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(tests.HERE), bare=True)
# Set some milestones
repo = pagure.lib.get_project(self.session, 'test')
self.assertEqual(repo.milestones, {})
user = tests.FakeUser()
user.username = '******'
with tests.user_set(pagure.APP, user):
# Get the CSRF token
output = self.app.get('/test/settings')
self.assertEqual(output.status_code, 200)
self.assertIn(u'<title>Settings - test - Pagure</title>',
output.data)
self.assertIn(u'<h3>Settings for test</h3>', output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'milestones': 1,
'milestone_dates': 'Tomorrow',
}
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('<h3>Settings for test</h3>', output.data)
# Check the result of the action -- None, no CSRF
repo = pagure.lib.get_project(self.session, 'test')
self.assertEqual(repo.milestones, {})
data = {
'milestones': 1,
'milestone_dates': 'Tomorrow',
'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'1': u'Tomorrow'})
data = {
'milestones': ['v1.0', 'v2.0'],
'milestone_dates': ['Tomorrow', ''],
'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'Tomorrow',
u'v2.0': u''
})
# Check error - less milestones than dates
data = {
'milestones': ['v1.0', 'v2.0'],
'milestone_dates': ['Tomorrow', 'Next week', 'Next Year'],
'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'</button>\n'
' Milestones and dates are not of the '
'same length', output.data)
# Check the result of the action -- Milestones un-changed
repo = pagure.lib.get_project(self.session, 'test')
self.assertEqual(repo.milestones, {
u'v1.0': u'Tomorrow',
u'v2.0': u''
})
# Check error - Twice the same milestone
data = {
'milestones': ['v1.0', 'v2.0', 'v2.0'],
'milestone_dates': ['Tomorrow', 'Next week', 'Next Year'],
'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'</button>\n'
' Milestone v2.0 is present 2 times',
output.data)
# Check the result of the action -- Milestones un-changed
repo = pagure.lib.get_project(self.session, 'test')
self.assertEqual(repo.milestones, {
u'v1.0': u'Tomorrow',
u'v2.0': u''
})
# Check error - Twice the same date
data = {
'milestones': ['v1.0', 'v2.0', 'v3.0'],
'milestone_dates': ['Tomorrow', 'Next week', 'Next week'],
'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'</button>\n'
' Date Next week is present 2 times',
output.data)
# Check the result of the action -- Milestones un-changed
repo = pagure.lib.get_project(self.session, 'test')
self.assertEqual(repo.milestones, {
u'v1.0': u'Tomorrow',
u'v2.0': u''
})
# 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(pagure.APP, user):
output = self.app.post('/test/update/milestones', data=data)
self.assertEqual(output.status_code, 403)
def test_plugin_mail(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.assertTrue('<p>test project #1</p>' in output.data)
self.assertTrue('<h3>Fedmsg</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.assertTrue('<p>test project #1</p>' in output.data)
self.assertTrue('<h3>Fedmsg</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.assertTrue('<h2>Settings</h2>' in output.data)
self.assertIn(
'<li class="message">Hook Fedmsg inactived</li>',
output.data)
output = self.app.get('/test/settings/Fedmsg', data=data)
self.assertTrue('<p>test project #1</p>' in output.data)
self.assertIn('<h3>Fedmsg</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.assertTrue('<h2>Settings</h2>' in output.data)
self.assertIn(
'<li class="message">Hook Fedmsg activated</li>',
output.data)
output = self.app.get('/test/settings/Fedmsg', data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue('<p>test project #1</p>' in output.data)
self.assertTrue('<h3>Fedmsg</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.assertTrue('<h2>Settings</h2>' in output.data)
self.assertIn(
'<li class="message">Hook Fedmsg inactived</li>',
output.data)
output = self.app.get('/test/settings/Fedmsg', data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue('<p>test project #1</p>' in output.data)
self.assertTrue('<h3>Fedmsg</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_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(tests.HERE), bare=True)
# Set some milestone
repo = pagure.lib.get_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(pagure.APP, user):
# Get the CSRF token
output = self.app.get('/test/new_issue')
self.assertEqual(output.status_code, 200)
self.assertTrue(
u'<div class="card-header">\n New issue' in output.data)
csrf_token = output.data.split(
u'name="csrf_token" type="hidden" value="')[1].split(u'">')[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)
self.assertIn(
u'<title>Issue #1: Test issue - test - Pagure</title>',
output.data)
self.assertIn(
u'<a class="btn btn-primary btn-sm" '
'href="/test/issue/1/edit" title="Edit this issue">',
output.data)
# 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)
self.assertIn(
u'<title>Issue #1: Test issue - test - Pagure</title>',
output.data)
self.assertIn(
u'<a class="btn btn-primary btn-sm" '
'href="/test/issue/1/edit" title="Edit this issue">',
output.data)
self.assertIn(
u'</button>\n '
u'Successfully edited issue #1', output.data)
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,
)
