def test_view_file_from_tree(self):
tests.add_content_git_repo(os.path.join(self.path, "repos",
"test.git"))
repo = pygit2.Repository(os.path.join(self.path, "repos", "test.git"))
commit = repo.revparse_single("HEAD")
output = self.app.get("/api/0/test/tree/%s/f/folder1" %
commit.tree.oid.hex)
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(
data,
{
"content": [{
"content_url":
"http://localhost/api/0/test/tree/"
"%s/f/folder1/folder2" % commit.tree.oid.hex,
"name":
"folder2",
"path":
"folder1/folder2",
"type":
"folder",
}],
"name":
"folder1",
"type":
"folder",
},
)
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 test_edit_with_all_allowed(self):
"""Tests that editing a file is possible if ACLs say allowed."""
user = tests.FakeUser()
user.username = '******'
with tests.user_set(self.app.application, user):
# Add some content to the git repo
tests.add_content_git_repo(
os.path.join(self.path, 'repos', 'hooktest.git'))
data = {
'content': 'foo\n bar\n baz',
'commit_title': 'test commit',
'commit_message': 'Online commits from the gure.lib.get',
'email': '*****@*****.**',
'branch': 'master',
'csrf_token': self.get_csrf(),
}
output = self.app.post(
'/hooktest/edit/master/f/sources', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn(
'<title>Commits - hooktest - Pagure</title>', output_text)
self.assertIn('test commit', output_text)
# Check file after the commit
output = self.app.get('/hooktest/raw/master/f/sources')
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, 'foo\n bar\n baz')
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureMergePrNoForkTest, self).setUp()
tests.create_projects(self.session)
tests.add_content_git_repo(
os.path.join(self.path, "repos", "test.git")
)
# Fork
project = pagure.lib.query.get_authorized_project(self.session, "test")
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",
"namespace": None,
"username": "******",
},
)
tests.add_readme_git_repo(
os.path.join(self.path, "repos", "forks", "pingou", "test.git")
)
project = pagure.lib.query.get_authorized_project(self.session, "test")
fork = pagure.lib.query.get_authorized_project(
self.session, "test", user="******"
)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
req = pagure.lib.query.new_pull_request(
session=self.session,
repo_from=fork,
branch_from="master",
repo_to=project,
branch_to="master",
title="test pull-request",
user="******",
)
self.session.commit()
self.assertEqual(req.id, 1)
self.assertEqual(req.title, "test pull-request")
# Assert the PR is open
self.session = pagure.lib.query.create_session(self.dbpath)
project = pagure.lib.query.get_authorized_project(self.session, "test")
self.assertEqual(len(project.requests), 1)
self.assertEqual(project.requests[0].status, "Open")
# Check how the PR renders in the API and the UI
output = self.app.get("/api/0/test/pull-request/1")
self.assertEqual(output.status_code, 200)
output = self.app.get("/test/pull-request/1")
self.assertEqual(output.status_code, 200)
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiForkUpdatetests, self).setUp()
tests.create_projects(self.session)
tests.add_content_git_repo(
os.path.join(self.path, "repos", "test.git")
)
# Fork
project = pagure.lib.query.get_authorized_project(self.session, "test")
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",
"namespace": None,
"username": "******",
},
)
tests.add_readme_git_repo(
os.path.join(self.path, "repos", "forks", "pingou", "test.git")
)
project = pagure.lib.query.get_authorized_project(self.session, "test")
fork = pagure.lib.query.get_authorized_project(
self.session, "test", user="******"
)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
req = pagure.lib.query.new_pull_request(
session=self.session,
repo_from=fork,
branch_from="master",
repo_to=project,
branch_to="master",
title="test pull-request",
user="******",
)
self.session.commit()
self.assertEqual(req.id, 1)
self.assertEqual(req.title, "test pull-request")
# Assert the PR is open
self.session = pagure.lib.query.create_session(self.dbpath)
project = pagure.lib.query.get_authorized_project(self.session, "test")
self.assertEqual(len(project.requests), 1)
self.assertEqual(project.requests[0].status, "Open")
# Check how the PR renders in the API and the UI
output = self.app.get("/api/0/test/pull-request/1")
self.assertEqual(output.status_code, 200)
output = self.app.get("/test/pull-request/1")
self.assertEqual(output.status_code, 200)
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(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(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 setUp(self):
super(PagureFlaskAppClonetests, 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",
"test.git"))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
self.create_project_full("clonetest", {"create_readme": "y"})
def test_view_file_invalid_folder(self):
tests.add_content_git_repo(os.path.join(self.path, "repos",
"test.git"))
output = self.app.get("/api/0/test/tree/master/f/inv/invalid")
self.assertEqual(output.status_code, 404)
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(
data,
{
"error": "File not found in this git repository",
"error_code": "EFILENOTFOUND",
},
)
def test_view_file_specific_file(self):
tests.add_content_git_repo(os.path.join(self.path, "repos",
"test.git"))
output = self.app.get("/api/0/test/tree/master/f/README.rst")
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(
data,
{
"content_url": "http://localhost/test/raw/master/f/README.rst",
"name": "README.rst",
"type": "file",
},
)
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskRepoViewFiletests, 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')
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_edit_with_all_denied(self):
"""Tests that editing a file is not possible if ACLs say denied."""
self.set_auth_status(False)
user = tests.FakeUser()
user.username = "******"
with tests.user_set(self.app.application, user):
# Add some content to the git repo
tests.add_content_git_repo(
os.path.join(self.path, "repos", "hooktest.git")
)
data = {
"content": "foo\n bar\n baz",
"commit_title": "test commit",
"commit_message": "Online commits from the gure.lib.get",
"email": "*****@*****.**",
"branch": "master",
"csrf_token": self.get_csrf(),
}
output = self.app.post(
"/hooktest/edit/master/f/sources",
data=data,
follow_redirects=True,
)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn(
"Remote hook declined the push: "
"Denied push for ref 'refs/heads/master' for user 'pingou'",
output_text,
)
self.assertIn("All changes have been rejected", output_text)
# Check file after the commit:
output = self.app.get("/hooktest/raw/master/f/sources")
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, "foo\n bar")
def test_view_file_valid_branch(self):
tests.add_content_git_repo(os.path.join(self.path, "repos",
"test.git"))
output = self.app.get("/api/0/test/tree/master/f/folder1")
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(
data,
{
"content": [{
"content_url": "http://localhost/api/0/test/tree/"
"master/f/folder1/folder2",
"name": "folder2",
"path": "folder1/folder2",
"type": "folder",
}],
"name":
"folder1",
"type":
"folder",
},
)
def test_edit_with_all_denied(self):
"""Tests that editing a file is not possible if ACLs say denied."""
self.set_auth_status(False)
user = tests.FakeUser()
user.username = "******"
with tests.user_set(self.app.application, user):
# Add some content to the git repo
tests.add_content_git_repo(
os.path.join(self.path, "repos", "hooktest.git"))
data = {
"content": "foo\n bar\n baz",
"commit_title": "test commit",
"commit_message": "Online commits from the gure.lib.get",
"email": "*****@*****.**",
"branch": "master",
"csrf_token": self.get_csrf(),
}
output = self.app.post(
"/hooktest/edit/master/f/sources",
data=data,
follow_redirects=True,
)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn(
"Remote hook declined the push: "
"Denied push for ref 'refs/heads/master' for user 'pingou'",
output_text,
)
self.assertIn("All changes have been rejected", output_text)
# Check file after the commit:
output = self.app.get("/hooktest/raw/master/f/sources")
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, "foo\n bar")
def test_view_file_with_folder(self):
tests.add_content_git_repo(os.path.join(self.path, "repos",
"test.git"))
output = self.app.get("/api/0/test/tree")
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(
data,
{
"content": [
{
"content_url": "http://localhost/api/0/test/tree/"
"master/f/folder1",
"name": "folder1",
"path": "folder1",
"type": "folder",
},
{
"content_url": "http://localhost/test/raw/master/f/"
"README.rst",
"name": "README.rst",
"path": "README.rst",
"type": "file",
},
{
"content_url": "http://localhost/test/raw/master/f/"
"sources",
"name": "sources",
"path": "sources",
"type": "file",
},
],
"name":
None,
"type":
"folder",
},
)
def test_view_blame_file_fork_of_a_fork(self):
""" Test the view_blame_file endpoint """
item = pagure.lib.model.Project(
user_id=1, # pingou
name="test3",
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", "test3.git"))
tests.add_readme_git_repo(
os.path.join(self.path, "repos", "forks", "pingou", "test3.git"))
tests.add_commit_git_repo(
os.path.join(self.path, "repos", "forks", "pingou", "test3.git"),
ncommits=10,
)
tests.add_content_to_git(
os.path.join(self.path, "repos", "forks", "pingou", "test3.git"),
content="✨☃🍰☃✨",
)
output = self.app.get("/fork/pingou/test3/blame/sources")
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn('<table class="code_table">', output_text)
self.assertTrue('<tr><td class="cell1"><a id="1" href="#1" '
'data-line-number="1"></a></td>' in output_text
or '<tr><td class="cell1"><a data-line-number="1" '
'href="#1" id="1"></a></td>' in output_text)
self.assertIn(
'<td class="cell2"><pre><code> barRow 0</code></pre></td>',
output_text,
)
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_edit_with_all_denied(self):
"""Tests that editing a file is not possible if ACLs say denied."""
self.set_auth_status(False)
user = tests.FakeUser()
user.username = '******'
with tests.user_set(self.app.application, user):
# Add some content to the git repo
tests.add_content_git_repo(
os.path.join(self.path, 'repos', 'hooktest.git'))
data = {
'content': 'foo\n bar\n baz',
'commit_title': 'test commit',
'commit_message': 'Online commits from the gure.lib.get',
'email': '*****@*****.**',
'branch': 'master',
'csrf_token': self.get_csrf(),
}
output = self.app.post(
'/hooktest/edit/master/f/sources', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn(
"Remote hook declined the push: "
"Denied push for ref 'refs/heads/master' for user 'pingou'\n"
"All changes have been rejected",
output_text
)
# Check file after the commit:
output = self.app.get('/hooktest/raw/master/f/sources')
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, 'foo\n bar')
def test_edit_with_all_allowed(self):
"""Tests that editing a file is possible if ACLs say allowed."""
user = tests.FakeUser()
user.username = "******"
with tests.user_set(self.app.application, user):
# Add some content to the git repo
tests.add_content_git_repo(
os.path.join(self.path, "repos", "hooktest.git")
)
data = {
"content": "foo\n bar\n baz",
"commit_title": "test commit",
"commit_message": "Online commits from the gure.lib.get",
"email": "*****@*****.**",
"branch": "master",
"csrf_token": self.get_csrf(),
}
output = self.app.post(
"/hooktest/edit/master/f/sources",
data=data,
follow_redirects=True,
)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn(
"<title>Commits - hooktest - Pagure</title>", output_text
)
self.assertIn("test commit", output_text)
# Check file after the commit
output = self.app.get("/hooktest/raw/master/f/sources")
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, "foo\n bar\n baz")
def test_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_view_commit_old(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"))
repo = pygit2.Repository(os.path.join(self.path, "repos", "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(
'href="#commit-overview-collapse"' in output.get_data(as_text=True)
)
self.assertTrue(
"Merged by Alice Author" in output.get_data(as_text=True)
)
self.assertTrue(
"Committed by Cecil Committer" in output.get_data(as_text=True)
)
self.assertTrue(
'title="View file as of %s"' % commit.oid.hex[0:6]
in output.get_data(as_text=True)
)
# 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(
'href="#commit-overview-collapse"' in output.get_data(as_text=True)
)
self.assertTrue(
"Merged by Alice Author" in output.get_data(as_text=True)
)
self.assertTrue(
"Committed by Cecil Committer" in output.get_data(as_text=True)
)
# Add some content to the git repo
tests.add_content_git_repo(
os.path.join(self.path, "repos", "test.git")
)
repo = pygit2.Repository(os.path.join(self.path, "repos", "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(
'href="#commit-overview-collapse"' in output.get_data(as_text=True)
)
self.assertTrue(
"Authored by Alice Author" in output.get_data(as_text=True)
)
self.assertTrue(
"Committed by Cecil Committer" in output.get_data(as_text=True)
)
# 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, "repos", "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(
'href="#commit-overview-collapse"' in output.get_data(as_text=True)
)
self.assertTrue(
" Authored by Alice Author\n" in output.get_data(as_text=True)
)
self.assertTrue(
" Committed by Cecil Committer\n" in output.get_data(as_text=True)
)
self.assertTrue(
'title="View file as of %s"' % commit.oid.hex[0:6]
in output.get_data(as_text=True)
)
# 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(
'href="#commit-overview-collapse"' in output.get_data(as_text=True)
)
self.assertTrue(
"Authored by Alice Author" in output.get_data(as_text=True)
)
self.assertTrue(
"Committed by Cecil Committer" in output.get_data(as_text=True)
)
# 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.get_data(as_text=True)
)
def insert_data(session, username, user_email):
pagure.APP.config['EMAIL_SEND'] = False
pagure.APP.config['TESTING'] = True
######################################
# tags
item = pagure.lib.model.Tag(tag='tag1', )
session.add(item)
session.commit()
######################################
# Users
# Create a couple of users
item = pagure.lib.model.User(
user='******',
fullname='PY C',
password='******',
default_email='*****@*****.**',
)
session.add(item)
session.commit()
item = pagure.lib.model.User(
user='******',
fullname='foo bar',
password='******',
default_email='*****@*****.**',
)
session.add(item)
session.commit()
item = pagure.lib.model.User(
user=username,
fullname=username,
password='******',
default_email=user_email,
)
session.add(item)
session.commit()
######################################
# pagure_group
item = pagure.lib.model.PagureGroup(
group_name='admin',
user_id=1,
display_name='admin',
description='Admin Group',
)
session.add(item)
session.commit()
# Add a couple of groups so that we can list them
item = pagure.lib.model.PagureGroup(
group_name='group',
group_type='user',
user_id=1, # pingou
display_name='group group',
description='this is a group group',
)
session.add(item)
session.commit()
item = pagure.lib.model.PagureGroup(
group_name='rel-eng',
group_type='user',
user_id=1, # pingou
display_name='Release Engineering',
description='The group of release engineers',
)
session.add(item)
session.commit()
######################################
# projects
import shutil
# delete folder from local instance to start from a clean slate
if os.path.exists(pagure.APP.config['GIT_FOLDER']):
shutil.rmtree(pagure.APP.config['GIT_FOLDER'])
tests.create_projects(session)
tests.create_projects_git(pagure.APP.config['GIT_FOLDER'], bare=True)
tests.add_content_git_repo(
os.path.join(pagure.APP.config['GIT_FOLDER'], 'test.git'))
tests.add_readme_git_repo(
os.path.join(pagure.APP.config['GIT_FOLDER'], 'test.git'))
# Add some content to the git repo
tests.add_content_git_repo(
os.path.join(pagure.APP.config['GIT_FOLDER'], 'forks', 'pingou',
'test.git'))
tests.add_readme_git_repo(
os.path.join(pagure.APP.config['GIT_FOLDER'], 'forks', 'pingou',
'test.git'))
tests.add_commit_git_repo(os.path.join(pagure.APP.config['GIT_FOLDER'],
'forks', 'pingou', 'test.git'),
ncommits=10)
######################################
# user_emails
item = pagure.lib.model.UserEmail(user_id=1, email='*****@*****.**')
session.add(item)
item = pagure.lib.model.UserEmail(user_id=1, email='*****@*****.**')
session.add(item)
item = pagure.lib.model.UserEmail(user_id=2, email='*****@*****.**')
session.add(item)
item = pagure.lib.model.UserEmail(user_id=3, email=user_email)
session.add(item)
session.commit()
######################################
# user_emails_pending
user = pagure.lib.search_user(session, username='******')
email_pend = pagure.lib.model.UserEmailPending(
user_id=user.id,
email='[email protected]',
token='abcdef',
)
session.add(email_pend)
session.commit()
######################################
# issues
# Add an issue and tag it so that we can list them
item = pagure.lib.model.Issue(
id=1,
uid='foobar',
project_id=1,
title='Problem with jenkins build',
content='For some reason the tests fail at line:24',
user_id=1, # pingou
)
session.add(item)
session.commit()
item = pagure.lib.model.Issue(
id=2,
uid='foobar2',
project_id=1,
title='Unit tests failing',
content='Need to fix code for the unit tests to '
'pass so jenkins build can complete.',
user_id=1, # pingou
)
session.add(item)
session.commit()
user = pagure.lib.search_user(session, username=username)
item = pagure.lib.model.Issue(
id=3,
uid='foobar3',
project_id=1,
title='Segfault during execution',
content='Index out of bounds for variable i?',
user_id=user.id, # current user
)
session.add(item)
session.commit()
######################################
# pagure_user_group
group = pagure.lib.search_groups(session,
pattern=None,
group_name="rel-eng",
group_type=None)
user = pagure.lib.search_user(session, username='******')
item = pagure.lib.model.PagureUserGroup(user_id=user.id, group_id=group.id)
session.add(item)
session.commit()
user = pagure.lib.search_user(session, username=username)
group = pagure.lib.search_groups(session,
pattern=None,
group_name="admin",
group_type=None)
item = pagure.lib.model.PagureUserGroup(user_id=user.id, group_id=group.id)
session.add(item)
session.commit()
user = pagure.lib.search_user(session, username='******')
group = pagure.lib.search_groups(session,
pattern=None,
group_name="group",
group_type=None)
item = pagure.lib.model.PagureUserGroup(user_id=user.id, group_id=group.id)
session.add(item)
session.commit()
######################################
# projects_groups
group = pagure.lib.search_groups(session,
pattern=None,
group_name="rel-eng",
group_type=None)
repo = pagure.get_authorized_project(session, 'test')
item = pagure.lib.model.ProjectGroup(project_id=repo.id, group_id=group.id)
session.add(item)
session.commit()
group = pagure.lib.search_groups(session,
pattern=None,
group_name="admin",
group_type=None)
repo = pagure.get_authorized_project(session, 'test2')
item = pagure.lib.model.ProjectGroup(project_id=repo.id, group_id=group.id)
session.add(item)
session.commit()
######################################
# pull_requests
repo = pagure.get_authorized_project(session, 'test')
forked_repo = pagure.get_authorized_project(session, 'test')
req = pagure.lib.new_pull_request(
session=session,
repo_from=forked_repo,
branch_from='master',
repo_to=repo,
branch_to='master',
title='Fixing code for unittest',
user=username,
requestfolder=None,
)
session.commit()
######################################
# tokens
tests.create_tokens(session)
######################################
# user_projects
user = pagure.lib.search_user(session, username='******')
repo = pagure.get_authorized_project(session, 'test')
item = pagure.lib.model.ProjectUser(project_id=repo.id, user_id=user.id)
session.add(item)
session.commit()
user = pagure.lib.search_user(session, username=username)
repo = pagure.get_authorized_project(session, 'test2')
item = pagure.lib.model.ProjectUser(project_id=repo.id, user_id=user.id)
session.add(item)
session.commit()
######################################
# issue_comments
item = pagure.lib.model.IssueComment(
user_id=1,
issue_uid='foobar',
comment='We may need to adjust the unittests instead of the code.',
)
session.add(item)
session.commit()
######################################
# issue_to_issue
repo = pagure.get_authorized_project(session, 'test')
all_issues = pagure.lib.search_issues(session, repo)
pagure.lib.add_issue_dependency(session, all_issues[0], all_issues[1],
'pingou', pagure.APP.config['GIT_FOLDER'])
######################################
# pull_request_comments
user = pagure.lib.search_user(session, username='******')
# only 1 pull request available atm
pr = pagure.lib.get_pull_request_of_user(session, "pingou")[0]
item = pagure.lib.model.PullRequestComment(
pull_request_uid=pr.uid,
user_id=user.id,
comment="+1 for me. Btw, could you rebase before you merge?",
notification=0)
session.add(item)
session.commit()
######################################
# pull_request_flags
user = pagure.lib.search_user(session, username='******')
# only 1 pull request available atm
pr = pagure.lib.get_pull_request_of_user(session, "pingou")[0]
item = pagure.lib.model.PullRequestFlag(uid="random_pr_flag_uid",
pull_request_uid=pr.uid,
user_id=user.id,
username=user.user,
percent=80,
comment="Jenkins build passes",
url=str(pr.id))
session.add(item)
session.commit()
######################################
# tags_issues
repo = pagure.get_authorized_project(session, 'test')
issues = pagure.lib.search_issues(session, repo)
item = pagure.lib.model.TagIssue(
issue_uid=issues[0].uid,
tag='Blocker',
)
session.add(item)
session.commit()
######################################
# tokens_acls
tests.create_tokens_acl(session)
######################################
# Fork a project
# delete fork data
fork_proj_location = "forks/foo/test.git"
try:
shutil.rmtree(
os.path.join(pagure.APP.config['GIT_FOLDER'], fork_proj_location))
except:
print('git folder already deleted')
try:
shutil.rmtree(
os.path.join(pagure.APP.config['DOCS_FOLDER'], fork_proj_location))
except:
print('docs folder already deleted')
try:
shutil.rmtree(
os.path.join(pagure.APP.config['TICKETS_FOLDER'],
fork_proj_location))
except:
print('tickets folder already deleted')
try:
shutil.rmtree(
os.path.join(pagure.APP.config['REQUESTS_FOLDER'],
fork_proj_location))
except:
print('requests folder already deleted')
repo = pagure.get_authorized_project(session, 'test')
result = pagure.lib.fork_project(session, 'foo', repo,
pagure.APP.config['GIT_FOLDER'],
pagure.APP.config['DOCS_FOLDER'],
pagure.APP.config['TICKETS_FOLDER'],
pagure.APP.config['REQUESTS_FOLDER'])
if result == 'Repo "test" cloned to "foo/test"':
session.commit()
def test_view_commit_old(self):
""" Test the view_commit_old endpoint. """
tests.create_projects(self.session)
tests.create_projects_git(tests.HERE, bare=True)
# Add a README to the git repo - First commit
tests.add_readme_git_repo(os.path.join(tests.HERE, 'test.git'))
repo = pygit2.Repository(os.path.join(tests.HERE, '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('</a> Authored by Alice Author' in output.data)
self.assertTrue('Committed by Cecil Committer' 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('</a> Authored by Alice Author' in output.data)
self.assertTrue('Committed by Cecil Committer' 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(tests.HERE, 'test.git'))
repo = pygit2.Repository(os.path.join(tests.HERE, '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('</a> Authored by Alice Author' in output.data)
self.assertTrue('Committed by Cecil Committer' 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(
tests.HERE, '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('</a> Authored by Alice Author' in output.data)
self.assertTrue('Committed by Cecil Committer' 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('</a> Authored by Alice Author' in output.data)
self.assertTrue('Committed by Cecil Committer' 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_edit_pr(self):
"""Tests the ACLs if they only accept PRs."""
self.set_auth_status({
'refs/heads/master': 'pronly',
'refs/heads/source': True
})
user = tests.FakeUser()
user.username = '******'
with tests.user_set(self.app.application, user):
# Add some content to the git repo
tests.add_content_git_repo(
os.path.join(self.path, 'repos', 'hooktest.git'))
# Try editing master branch, should fail (only PRs allowed)
data = {
'content': 'foo\n bar\n baz',
'commit_title': 'test commit',
'commit_message': 'Online commits from the gure.lib.get',
'email': '*****@*****.**',
'branch': 'master',
'csrf_token': self.get_csrf(),
}
output = self.app.post('/hooktest/edit/master/f/sources',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn(
"Remote hook declined the push: "
"Denied push for ref 'refs/heads/master' for user 'pingou'\n"
"All changes have been rejected", output_text)
# Change something in the "source" branch
data = {
'content': 'foo\n bar\n baz',
'commit_title': 'test commit',
'commit_message': 'Online commits from the gure.lib.get',
'email': '*****@*****.**',
'branch': 'source',
'csrf_token': self.get_csrf(),
}
output = self.app.post('/hooktest/edit/master/f/sources',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn('<title>Commits - hooktest - Pagure</title>',
output_text)
self.assertIn('test commit', output_text)
# Check file after the commit:
output = self.app.get('/hooktest/raw/source/f/sources')
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, 'foo\n bar\n baz')
# Create the PRs
project = pagure.lib.query.get_authorized_project(
self.session, 'hooktest')
req = pagure.lib.query.new_pull_request(
session=self.session,
repo_from=project,
branch_from="source",
repo_to=project,
branch_to='master',
title='PR to master',
user='******',
)
self.session.add(req)
self.session.commit()
# Check file before the merge
output = self.app.get('/hooktest/raw/master/f/sources')
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, 'foo\n bar')
# Try to merge (should work)
output = self.app.post('/hooktest/pull-request/1/merge',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn('<title>Overview - hooktest - Pagure</title>',
output_text)
# Check file after the merge
output = self.app.get('/hooktest/raw/master/f/sources')
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, 'foo\n bar\n baz')
def init_test_repo(self):
tests.add_content_git_repo(self.projects[0])
repo = pygit2.Repository(self.projects[0])
sha = repo.references["refs/heads/master"].peel().hex
project = pagure.lib.query.get_authorized_project(self.session, "test")
return project, sha
def test_view_commit_old(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'))
repo = pygit2.Repository(os.path.join(self.path, 'repos', '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('href="#commit-overview-collapse"' in output.get_data(
as_text=True))
self.assertTrue('Merged by Alice Author' in output.get_data(
as_text=True))
self.assertTrue('Committed by Cecil Committer' in output.get_data(
as_text=True))
self.assertTrue('title="View file as of %s"' %
commit.oid.hex[0:6] in output.get_data(as_text=True))
# 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('href="#commit-overview-collapse"' in output.get_data(
as_text=True))
self.assertTrue('Merged by Alice Author' in output.get_data(
as_text=True))
self.assertTrue('Committed by Cecil Committer' in output.get_data(
as_text=True))
# Add some content to the git repo
tests.add_content_git_repo(os.path.join(self.path, 'repos',
'test.git'))
repo = pygit2.Repository(os.path.join(self.path, 'repos', '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('href="#commit-overview-collapse"' in output.get_data(
as_text=True))
self.assertTrue('Authored by Alice Author' in output.get_data(
as_text=True))
self.assertTrue('Committed by Cecil Committer' in output.get_data(
as_text=True))
# 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, 'repos', '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('href="#commit-overview-collapse"' in output.get_data(
as_text=True))
self.assertTrue(' Authored by Alice Author\n' in output.get_data(
as_text=True))
self.assertTrue(' Committed by Cecil Committer\n' in output.get_data(
as_text=True))
self.assertTrue('title="View file as of %s"' %
commit.oid.hex[0:6] in output.get_data(as_text=True))
# 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('href="#commit-overview-collapse"' in output.get_data(
as_text=True))
self.assertTrue('Authored by Alice Author' in output.get_data(
as_text=True))
self.assertTrue('Committed by Cecil Committer' in output.get_data(
as_text=True))
# 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.get_data(as_text=True))
def test_edit_pr(self):
"""Tests the ACLs if they only accept PRs."""
self.set_auth_status({
"refs/heads/master": "pronly",
"refs/heads/source": True
})
user = tests.FakeUser()
user.username = "******"
with tests.user_set(self.app.application, user):
# Add some content to the git repo
tests.add_content_git_repo(
os.path.join(self.path, "repos", "hooktest.git"))
# Try editing master branch, should fail (only PRs allowed)
data = {
"content": "foo\n bar\n baz",
"commit_title": "test commit",
"commit_message": "Online commits from the gure.lib.get",
"email": "*****@*****.**",
"branch": "master",
"csrf_token": self.get_csrf(),
}
output = self.app.post(
"/hooktest/edit/master/f/sources",
data=data,
follow_redirects=True,
)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn(
"Remote hook declined the push: "
"Denied push for ref 'refs/heads/master' for user 'pingou'",
output_text,
)
self.assertIn("All changes have been rejected", output_text)
# Change something in the "source" branch
data = {
"content": "foo\n bar\n baz",
"commit_title": "test commit",
"commit_message": "Online commits from the gure.lib.get",
"email": "*****@*****.**",
"branch": "source",
"csrf_token": self.get_csrf(),
}
output = self.app.post(
"/hooktest/edit/master/f/sources",
data=data,
follow_redirects=True,
)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn("<title>Commits - hooktest - Pagure</title>",
output_text)
self.assertIn("test commit", output_text)
# Check file after the commit:
output = self.app.get("/hooktest/raw/source/f/sources")
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, "foo\n bar\n baz")
# Create the PRs
project = pagure.lib.query.get_authorized_project(
self.session, "hooktest")
req = pagure.lib.query.new_pull_request(
session=self.session,
repo_from=project,
branch_from="source",
repo_to=project,
branch_to="master",
title="PR to master",
user="******",
)
self.session.add(req)
self.session.commit()
# Check file before the merge
output = self.app.get("/hooktest/raw/master/f/sources")
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, "foo\n bar")
# Try to merge (should work)
output = self.app.post(
"/hooktest/pull-request/1/merge",
data=data,
follow_redirects=True,
)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn(
"<title>PR#1: PR to master - hooktest\n - Pagure</title>",
output_text,
)
# Check file after the merge
output = self.app.get("/hooktest/raw/master/f/sources")
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, "foo\n bar\n baz")
def test_edit_pr(self):
"""Tests the ACLs if they only accept PRs."""
self.set_auth_status(
{"refs/heads/master": "pronly", "refs/heads/source": True}
)
user = tests.FakeUser()
user.username = "******"
with tests.user_set(self.app.application, user):
# Add some content to the git repo
tests.add_content_git_repo(
os.path.join(self.path, "repos", "hooktest.git")
)
# Try editing master branch, should fail (only PRs allowed)
data = {
"content": "foo\n bar\n baz",
"commit_title": "test commit",
"commit_message": "Online commits from the gure.lib.get",
"email": "*****@*****.**",
"branch": "master",
"csrf_token": self.get_csrf(),
}
output = self.app.post(
"/hooktest/edit/master/f/sources",
data=data,
follow_redirects=True,
)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn(
"Remote hook declined the push: "
"Denied push for ref 'refs/heads/master' for user 'pingou'",
output_text,
)
self.assertIn("All changes have been rejected", output_text)
# Change something in the "source" branch
data = {
"content": "foo\n bar\n baz",
"commit_title": "test commit",
"commit_message": "Online commits from the gure.lib.get",
"email": "*****@*****.**",
"branch": "source",
"csrf_token": self.get_csrf(),
}
output = self.app.post(
"/hooktest/edit/master/f/sources",
data=data,
follow_redirects=True,
)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn(
"<title>Commits - hooktest - Pagure</title>", output_text
)
self.assertIn("test commit", output_text)
# Check file after the commit:
output = self.app.get("/hooktest/raw/source/f/sources")
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, "foo\n bar\n baz")
# Create the PRs
project = pagure.lib.query.get_authorized_project(
self.session, "hooktest"
)
req = pagure.lib.query.new_pull_request(
session=self.session,
repo_from=project,
branch_from="source",
repo_to=project,
branch_to="master",
title="PR to master",
user="******",
)
self.session.add(req)
self.session.commit()
# Check file before the merge
output = self.app.get("/hooktest/raw/master/f/sources")
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, "foo\n bar")
# Try to merge (should work)
output = self.app.post(
"/hooktest/pull-request/1/merge",
data=data,
follow_redirects=True,
)
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn(
"<title>Overview - hooktest - Pagure</title>", output_text
)
# Check file after the merge
output = self.app.get("/hooktest/raw/master/f/sources")
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertEqual(output_text, "foo\n bar\n baz")
def insert_data(session, username, user_email):
pagure.APP.config['EMAIL_SEND'] = False
pagure.APP.config['TESTING'] = True
######################################
# tags
item = pagure.lib.model.Tag(
tag='tag1',
)
session.add(item)
session.commit()
######################################
# Users
# Create a couple of users
item = pagure.lib.model.User(
user='******',
fullname='PY C',
password='******',
default_email='*****@*****.**',
)
session.add(item)
session.commit()
item = pagure.lib.model.User(
user='******',
fullname='foo bar',
password='******',
default_email='*****@*****.**',
)
session.add(item)
session.commit()
item = pagure.lib.model.User(
user=username,
fullname=username,
password='******',
default_email=user_email,
)
session.add(item)
session.commit()
######################################
# pagure_group
item = pagure.lib.model.PagureGroup(
group_name='admin',
user_id=1,
)
session.add(item)
session.commit()
# Add a couple of groups so that we can list them
item = pagure.lib.model.PagureGroup(
group_name='group',
group_type='user',
user_id=1, # pingou
)
session.add(item)
session.commit()
item = pagure.lib.model.PagureGroup(
group_name='rel-eng',
group_type='user',
user_id=1, # pingou
)
session.add(item)
session.commit()
######################################
# projects
import shutil
# delete folder from local instance to start from a clean slate
if os.path.exists(pagure.APP.config['GIT_FOLDER']):
shutil.rmtree(pagure.APP.config['GIT_FOLDER'])
tests.create_projects(session)
tests.create_projects_git(pagure.APP.config['GIT_FOLDER'], bare=True)
tests.add_content_git_repo(
os.path.join(pagure.APP.config['GIT_FOLDER'], 'test.git'))
tests.add_readme_git_repo(
os.path.join(pagure.APP.config['GIT_FOLDER'], 'test.git'))
# Add some content to the git repo
tests.add_content_git_repo(
os.path.join(pagure.APP.config['GIT_FOLDER'], 'forks', 'pingou',
'test.git'))
tests.add_readme_git_repo(
os.path.join(pagure.APP.config['GIT_FOLDER'], 'forks', 'pingou',
'test.git'))
tests.add_commit_git_repo(
os.path.join(pagure.APP.config['GIT_FOLDER'], 'forks', 'pingou',
'test.git'), ncommits=10)
######################################
# user_emails
item = pagure.lib.model.UserEmail(
user_id=1,
email='*****@*****.**')
session.add(item)
item = pagure.lib.model.UserEmail(
user_id=1,
email='*****@*****.**')
session.add(item)
item = pagure.lib.model.UserEmail(
user_id=2,
email='*****@*****.**')
session.add(item)
item = pagure.lib.model.UserEmail(
user_id=3,
email=user_email)
session.add(item)
session.commit()
######################################
# user_emails_pending
user = pagure.lib.search_user(session, username='******')
email_pend = pagure.lib.model.UserEmailPending(
user_id=user.id,
email='[email protected]',
token='abcdef',
)
session.add(email_pend)
session.commit()
######################################
# issues
# Add an issue and tag it so that we can list them
item = pagure.lib.model.Issue(
id=1,
uid='foobar',
project_id=1,
title='Problem with jenkins build',
content='For some reason the tests fail at line:24',
user_id=1, # pingou
)
session.add(item)
session.commit()
item = pagure.lib.model.Issue(
id=2,
uid='foobar2',
project_id=1,
title='Unit tests failing',
content='Need to fix code for the unit tests to '
'pass so jenkins build can complete.',
user_id=1, # pingou
)
session.add(item)
session.commit()
user = pagure.lib.search_user(session, username=username)
item = pagure.lib.model.Issue(
id=3,
uid='foobar3',
project_id=1,
title='Segfault during execution',
content='Index out of bounds for variable i?',
user_id=user.id, # current user
)
session.add(item)
session.commit()
######################################
# pagure_user_group
group = pagure.lib.search_groups(session, pattern=None,
group_name="rel-eng", group_type=None)
user = pagure.lib.search_user(session, username='******')
item = pagure.lib.model.PagureUserGroup(
user_id=user.id,
group_id=group.id
)
session.add(item)
session.commit()
user = pagure.lib.search_user(session, username=username)
group = pagure.lib.search_groups(session, pattern=None,
group_name="admin", group_type=None)
item = pagure.lib.model.PagureUserGroup(
user_id=user.id,
group_id=group.id
)
session.add(item)
session.commit()
user = pagure.lib.search_user(session, username='******')
group = pagure.lib.search_groups(session, pattern=None,
group_name="group", group_type=None)
item = pagure.lib.model.PagureUserGroup(
user_id=user.id,
group_id=group.id
)
session.add(item)
session.commit()
######################################
# projects_groups
group = pagure.lib.search_groups(session, pattern=None,
group_name="rel-eng", group_type=None)
repo = pagure.lib.get_project(session, 'test')
item = pagure.lib.model.ProjectGroup(
project_id=repo.id,
group_id=group.id
)
session.add(item)
session.commit()
group = pagure.lib.search_groups(session, pattern=None,
group_name="admin", group_type=None)
repo = pagure.lib.get_project(session, 'test2')
item = pagure.lib.model.ProjectGroup(
project_id=repo.id,
group_id=group.id
)
session.add(item)
session.commit()
######################################
# pull_requests
repo = pagure.lib.get_project(session, 'test')
forked_repo = pagure.lib.get_project(session, 'test')
req = pagure.lib.new_pull_request(
session=session,
repo_from=forked_repo,
branch_from='master',
repo_to=repo,
branch_to='master',
title='Fixing code for unittest',
user=username,
requestfolder=None,
)
session.commit()
######################################
# tokens
tests.create_tokens(session)
######################################
# user_projects
user = pagure.lib.search_user(session, username='******')
repo = pagure.lib.get_project(session, 'test')
item = pagure.lib.model.ProjectUser(
project_id=repo.id,
user_id=user.id
)
session.add(item)
session.commit()
user = pagure.lib.search_user(session, username=username)
repo = pagure.lib.get_project(session, 'test2')
item = pagure.lib.model.ProjectUser(
project_id=repo.id,
user_id=user.id
)
session.add(item)
session.commit()
######################################
# issue_comments
item = pagure.lib.model.IssueComment(
user_id=1,
issue_uid='foobar',
comment='We may need to adjust the unittests instead of the code.',
)
session.add(item)
session.commit()
######################################
# issue_to_issue
repo = pagure.lib.get_project(session, 'test')
all_issues = pagure.lib.search_issues(session, repo)
pagure.lib.add_issue_dependency(session, all_issues[0],
all_issues[1], 'pingou',
pagure.APP.config['GIT_FOLDER'])
######################################
# pull_request_comments
user = pagure.lib.search_user(session, username='******')
# only 1 pull request available atm
pr = pagure.lib.get_pull_request_of_user(session, "pingou")[0]
item = pagure.lib.model.PullRequestComment(
pull_request_uid=pr.uid,
user_id=user.id,
comment="+1 for me. Btw, could you rebase before you merge?",
notification=0
)
session.add(item)
session.commit()
######################################
# pull_request_flags
user = pagure.lib.search_user(session, username='******')
# only 1 pull request available atm
pr = pagure.lib.get_pull_request_of_user(session, "pingou")[0]
item = pagure.lib.model.PullRequestFlag(
uid="random_pr_flag_uid",
pull_request_uid=pr.uid,
user_id=user.id,
username=user.user,
percent=80,
comment="Jenkins build passes",
url=str(pr.id)
)
session.add(item)
session.commit()
######################################
# tags_issues
repo = pagure.lib.get_project(session, 'test')
issues = pagure.lib.search_issues(session, repo)
item = pagure.lib.model.TagIssue(
issue_uid=issues[0].uid,
tag='Blocker',
)
session.add(item)
session.commit()
######################################
# tokens_acls
tests.create_tokens_acl(session)
######################################
# Fork a project
# delete fork data
fork_proj_location = "forks/foo/test.git"
try:
shutil.rmtree(os.path.join(pagure.APP.config['GIT_FOLDER'],
fork_proj_location))
except:
print('git folder already deleted')
try:
shutil.rmtree(os.path.join(pagure.APP.config['DOCS_FOLDER'],
fork_proj_location))
except:
print('docs folder already deleted')
try:
shutil.rmtree(os.path.join(pagure.APP.config['TICKETS_FOLDER'],
fork_proj_location))
except:
print('tickets folder already deleted')
try:
shutil.rmtree(os.path.join(pagure.APP.config['REQUESTS_FOLDER'],
fork_proj_location))
except:
print('requests folder already deleted')
repo = pagure.lib.get_project(session, 'test')
result = pagure.lib.fork_project(session, 'foo', repo,
pagure.APP.config['GIT_FOLDER'],
pagure.APP.config['DOCS_FOLDER'],
pagure.APP.config['TICKETS_FOLDER'],
pagure.APP.config['REQUESTS_FOLDER'])
if result == 'Repo "test" cloned to "foo/test"':
session.commit()
