def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureRebasetests, 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='test',
content="foobar")
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=project,
branch_from='test',
repo_to=project,
branch_to='master',
title='PR from the test branch',
user='******',
)
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 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_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_view_history_file_fork_of_a_fork(self):
""" Test the view_history_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/history/sources")
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn("<strong>Add row 2 to sources file</strong>",
output_text)
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(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(ViewCommitFlagtests, self).setUp()
tests.create_projects(self.session)
tests.create_tokens(self.session)
# 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"))
self.commit = repo.revparse_single("HEAD")
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(ViewCommitFlagtests, self).setUp()
tests.create_projects(self.session)
tests.create_tokens(self.session)
# 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'))
self.commit = repo.revparse_single('HEAD')
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_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 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, 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",
)
tests.add_content_to_git(
os.path.join(self.path, "repos", "test.git"),
branch="test",
content="foobar",
filename="sources",
)
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=project,
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 setUp(self):
""" Set up the environnment, ran before every tests. """
super(ViewCommitFlagtests, self).setUp()
pagure.APP.config['TESTING'] = True
pagure.SESSION = self.session
pagure.ui.SESSION = self.session
pagure.ui.app.SESSION = self.session
pagure.ui.filters.SESSION = self.session
pagure.ui.repo.SESSION = self.session
tests.create_projects(self.session)
tests.create_tokens(self.session)
# 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'))
self.commit = repo.revparse_single('HEAD')
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(tests.HERE, 'repos'), bare=True)
project = pagure.lib.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(tests.HERE, 'repos'), 'test.git'))
repo = pygit2.Repository(
os.path.join(os.path.join(tests.HERE, '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(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.get_project(self.session, 'test2')
tests.add_readme_git_repo(
os.path.join(os.path.join(tests.HERE, 'repos'), 'test2.git'))
repo = pygit2.Repository(
os.path.join(os.path.join(tests.HERE, '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(repo, exp, 'test2.git')
tags = pagure.lib.git.get_git_tags_objects(project)
self.assertEqual(exp, get_tag_name(tags))
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(tests.HERE, 'repos'), bare=True)
project = pagure.lib.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(
tests.HERE, 'repos'), 'test.git'))
repo = pygit2.Repository(os.path.join(os.path.join(
tests.HERE, '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(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.get_project(self.session, 'test2')
tests.add_readme_git_repo(os.path.join(os.path.join(
tests.HERE, 'repos'), 'test2.git'))
repo = pygit2.Repository(os.path.join(os.path.join(
tests.HERE, '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(repo, exp, 'test2.git')
tags = pagure.lib.git.get_git_tags_objects(project)
self.assertEqual(exp, get_tag_name(tags))
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_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, 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 insert_data(session, username, user_email):
_config["EMAIL_SEND"] = False
_config["TESTING"] = True
######################################
# tags
item = pagure.lib.model.Tag(tag="tag1")
session.add(item)
session.commit()
######################################
# Users
# Create a couple of users
pingou = item = pagure.lib.model.User(
user="******",
fullname="PY C",
password=generate_hashed_value("testing123"),
token=None,
default_email="*****@*****.**",
)
session.add(item)
session.commit()
print(
"User created: {} <{}>, {}".format(
item.user, item.default_email, "testing123"
)
)
foo = item = pagure.lib.model.User(
user="******",
fullname="foo bar",
password=generate_hashed_value("testing123"),
token=None,
default_email="*****@*****.**",
)
session.add(item)
session.commit()
print(
"User created: {} <{}>, {}".format(
item.user, item.default_email, "testing123"
)
)
you = item = pagure.lib.model.User(
user=username,
fullname=username,
password=generate_hashed_value("testing123"),
token=None,
default_email=user_email,
)
session.add(item)
session.commit()
print(
"User created: {} <{}>, {}".format(
item.user, item.default_email, "testing123"
)
)
######################################
# pagure_group
item = pagure.lib.model.PagureGroup(
group_name="admin",
group_type="admin",
user_id=pingou.id,
display_name="admin",
description="Admin Group",
)
session.add(item)
session.commit()
print('Created "admin" group. Pingou is a member.')
# Add a couple of groups so that we can list them
item = pagure.lib.model.PagureGroup(
group_name="group",
group_type="user",
user_id=pingou.id,
display_name="group group",
description="this is a group group",
)
session.add(item)
session.commit()
print('Created "group" group. Pingou is a member.')
item = pagure.lib.model.PagureGroup(
group_name="rel-eng",
group_type="user",
user_id=pingou.id,
display_name="Release Engineering",
description="The group of release engineers",
)
session.add(item)
session.commit()
print('Created "rel-eng" group. Pingou is a member.')
######################################
# projects
import shutil
# delete folder from local instance to start from a clean slate
if os.path.exists(_config["GIT_FOLDER"]):
shutil.rmtree(_config["GIT_FOLDER"])
# Create projects
item = project1 = pagure.lib.model.Project(
user_id=pingou.id,
name="test",
is_fork=False,
parent_id=None,
description="test project #1",
hook_token="aaabbbccc",
)
item.close_status = ["Invalid", "Insufficient data", "Fixed", "Duplicate"]
session.add(item)
session.flush()
tests.create_locks(session, item)
item = project2 = pagure.lib.model.Project(
user_id=pingou.id,
name="test2",
is_fork=False,
parent_id=None,
description="test project #2",
hook_token="aaabbbddd",
)
item.close_status = ["Invalid", "Insufficient data", "Fixed", "Duplicate"]
session.add(item)
item = project3 = pagure.lib.model.Project(
user_id=pingou.id,
name="test3",
is_fork=False,
parent_id=None,
description="namespaced test project",
hook_token="aaabbbeee",
namespace="somenamespace",
)
item.close_status = ["Invalid", "Insufficient data", "Fixed", "Duplicate"]
session.add(item)
session.commit()
tests.create_projects_git(_config["GIT_FOLDER"], bare=True)
add_content_git_repo(os.path.join(_config["GIT_FOLDER"], "test.git"))
tests.add_readme_git_repo(os.path.join(_config["GIT_FOLDER"], "test.git"))
# Add some content to the git repo
add_content_git_repo(
os.path.join(_config["GIT_FOLDER"], "forks", "pingou", "test.git")
)
tests.add_readme_git_repo(
os.path.join(_config["GIT_FOLDER"], "forks", "pingou", "test.git")
)
tests.add_commit_git_repo(
os.path.join(_config["GIT_FOLDER"], "forks", "pingou", "test.git"),
ncommits=10,
)
######################################
# user_emails
item = pagure.lib.model.UserEmail(
user_id=pingou.id, email="*****@*****.**"
)
session.add(item)
item = pagure.lib.model.UserEmail(
user_id=pingou.id, email="*****@*****.**"
)
session.add(item)
item = pagure.lib.model.UserEmail(user_id=foo.id, email="*****@*****.**")
session.add(item)
item = pagure.lib.model.UserEmail(user_id=you.id, email=user_email)
session.add(item)
session.commit()
######################################
# user_emails_pending
email_pend = pagure.lib.model.UserEmailPending(
user_id=pingou.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=1001,
uid="foobar",
project_id=project1.id,
title="Problem with jenkins build",
content="For some reason the tests fail at line:24",
user_id=pingou.id,
)
session.add(item)
session.commit()
item = pagure.lib.model.Issue(
id=1002,
uid="foobar2",
project_id=project1.id,
title="Unit tests failing",
content="Need to fix code for the unit tests to "
"pass so jenkins build can complete.",
user_id=pingou.id,
)
session.add(item)
session.commit()
item = pagure.lib.model.Issue(
id=1003,
uid="foobar3",
project_id=project1.id,
title="Segfault during execution",
content="Index out of bounds for variable i?",
user_id=you.id,
)
session.add(item)
session.commit()
######################################
# pagure_user_group
group = pagure.lib.query.search_groups(
session, pattern=None, group_name="rel-eng", group_type=None
)
item = pagure.lib.model.PagureUserGroup(
user_id=pingou.id, group_id=group.id
)
session.add(item)
session.commit()
group = pagure.lib.query.search_groups(
session, pattern=None, group_name="admin", group_type=None
)
item = pagure.lib.model.PagureUserGroup(user_id=you.id, group_id=group.id)
session.add(item)
session.commit()
group = pagure.lib.query.search_groups(
session, pattern=None, group_name="group", group_type=None
)
item = pagure.lib.model.PagureUserGroup(user_id=foo.id, group_id=group.id)
session.add(item)
session.commit()
######################################
# projects_groups
group = pagure.lib.query.search_groups(
session, pattern=None, group_name="rel-eng", group_type=None
)
repo = pagure.lib.query.get_authorized_project(session, "test")
item = pagure.lib.model.ProjectGroup(
project_id=repo.id, group_id=group.id, access="commit"
)
session.add(item)
session.commit()
group = pagure.lib.query.search_groups(
session, pattern=None, group_name="admin", group_type=None
)
repo = pagure.lib.query.get_authorized_project(session, "test2")
item = pagure.lib.model.ProjectGroup(
project_id=repo.id, group_id=group.id, access="admin"
)
session.add(item)
session.commit()
######################################
# pull_requests
repo = pagure.lib.query.get_authorized_project(session, "test")
forked_repo = pagure.lib.query.get_authorized_project(session, "test")
req = pagure.lib.query.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,
status="Open",
)
session.commit()
repo = pagure.lib.query.get_authorized_project(session, "test")
forked_repo = pagure.lib.query.get_authorized_project(session, "test")
req = pagure.lib.query.new_pull_request(
session=session,
repo_from=forked_repo,
branch_from="master",
repo_to=repo,
branch_to="master",
title="add very nice README",
user=username,
status="Open",
)
session.commit()
repo = pagure.lib.query.get_authorized_project(session, "test")
forked_repo = pagure.lib.query.get_authorized_project(session, "test")
req = pagure.lib.query.new_pull_request(
session=session,
repo_from=forked_repo,
branch_from="master",
repo_to=repo,
branch_to="master",
title="Add README",
user=username,
status="Closed",
)
session.commit()
repo = pagure.lib.query.get_authorized_project(session, "test")
forked_repo = pagure.lib.query.get_authorized_project(session, "test")
req = pagure.lib.query.new_pull_request(
session=session,
repo_from=forked_repo,
branch_from="master",
repo_to=repo,
branch_to="master",
title="Fix some containers",
user=username,
status="Merged",
)
session.commit()
repo = pagure.lib.query.get_authorized_project(session, "test")
forked_repo = pagure.lib.query.get_authorized_project(session, "test")
req = pagure.lib.query.new_pull_request(
session=session,
repo_from=forked_repo,
branch_from="master",
repo_to=repo,
branch_to="master",
title="Fix pull request statuses",
user=username,
status="Closed",
)
session.commit()
repo = pagure.lib.query.get_authorized_project(session, "test")
forked_repo = pagure.lib.query.get_authorized_project(session, "test")
req = pagure.lib.query.new_pull_request(
session=session,
repo_from=forked_repo,
branch_from="master",
repo_to=repo,
branch_to="master",
title="Fixing UI of issue",
user=username,
status="Merged",
)
session.commit()
#####################################
# tokens
tests.create_tokens(session, user_id=pingou.id, project_id=project1.id)
######################################
# user_projects
repo = pagure.lib.query.get_authorized_project(session, "test")
item = pagure.lib.model.ProjectUser(
project_id=repo.id, user_id=foo.id, access="commit"
)
session.add(item)
session.commit()
repo = pagure.lib.query.get_authorized_project(session, "test2")
item = pagure.lib.model.ProjectUser(
project_id=repo.id, user_id=you.id, access="commit"
)
session.add(item)
session.commit()
######################################
# issue_comments
item = pagure.lib.model.IssueComment(
user_id=pingou.id,
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.query.get_authorized_project(session, "test")
all_issues = pagure.lib.query.search_issues(session, repo)
pagure.lib.query.add_issue_dependency(
session, all_issues[0], all_issues[1], "pingou"
)
######################################
# pull_request_comments
user = pagure.lib.query.search_user(session, username="******")
# only 1 pull request available atm
pr = pagure.lib.query.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
# only 1 pull request available atm
pr = pagure.lib.query.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=pingou.id,
username=pingou.user,
percent=80,
comment="Jenkins build passes",
url=str(pr.id),
status="success",
)
session.add(item)
session.commit()
pr = pagure.lib.query.get_pull_request_of_user(session, "foo")[1]
item = pagure.lib.model.PullRequestFlag(
uid="oink oink uid",
pull_request_uid=pr.uid,
user_id=pingou.id,
username=pingou.user,
percent=80,
comment="Jenkins does not pass",
url=str(pr.id),
status="failure",
)
session.add(item)
session.commit()
######################################
# pull_request_assignee
pr = pagure.lib.query.search_pull_requests(session, requestid="1006")
pr.assignee_id = pingou.id
session.commit()
pr = pagure.lib.query.search_pull_requests(session, requestid="1007")
pr.assignee_id = you.id
session.commit()
pr = pagure.lib.query.search_pull_requests(session, requestid="1004")
pr.assignee_id = foo.id
session.commit()
######################################
# tags_issues
repo = pagure.lib.query.get_authorized_project(session, "test")
issues = pagure.lib.query.search_issues(session, repo)
item = pagure.lib.model.TagIssue(issue_uid=issues[0].uid, tag="tag1")
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(_config["GIT_FOLDER"], fork_proj_location))
except:
print("git folder already deleted")
try:
shutil.rmtree(os.path.join(_config["DOCS_FOLDER"], fork_proj_location))
except:
print("docs folder already deleted")
try:
shutil.rmtree(
os.path.join(_config["TICKETS_FOLDER"], fork_proj_location)
)
except:
print("tickets folder already deleted")
try:
shutil.rmtree(
os.path.join(_config["REQUESTS_FOLDER"], fork_proj_location)
)
except:
print("requests folder already deleted")
repo = pagure.lib.query.get_authorized_project(session, "test")
result = pagure.lib.query.fork_project(session, "foo", repo)
if result == 'Repo "test" cloned to "foo/test"':
session.commit()
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureHooksPagureHooktests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
# Add one issue to each projects otherwise we won't be able to find
project = pagure.lib.query.get_authorized_project(self.session, "test")
msg = pagure.lib.query.new_issue(
session=self.session,
repo=project,
title="Test issue",
content="We should work on this",
user="******",
)
self.session.commit()
self.assertEqual(msg.title, "Test issue")
project = pagure.lib.query.get_authorized_project(
self.session, "test2")
msg = pagure.lib.query.new_issue(
session=self.session,
repo=project,
title="Test issue on test2",
content="We should work on this, really",
user="******",
)
self.session.commit()
self.assertEqual(msg.title, "Test issue on test2")
# Create a fork of test for foo with its own ticket
item = pagure.lib.model.Project(
user_id=2, # foo
name="test",
is_fork=True,
parent_id=1,
description="test project #1",
hook_token="aaabbbccc_foo",
)
item.close_status = [
"Invalid",
"Insufficient data",
"Fixed",
"Duplicate",
]
self.session.add(item)
self.session.commit()
project = pagure.lib.query.get_authorized_project(self.session,
"test",
user="******")
msg = pagure.lib.query.new_issue(
session=self.session,
repo=project,
title="Test issue on fork/foo/test",
content="We should work on this, really",
user="******",
)
self.session.commit()
self.assertEqual(msg.title, "Test issue on fork/foo/test")
self.folder = os.path.join(self.path, "repos", "test.git")
# Add a README to the git repo - First commit
tests.add_readme_git_repo(self.folder)
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureRebasetests, 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
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=True,
)
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 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()
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureHooksPagureHooktests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'repos'), bare=True)
# Add one issue to each projects otherwise we won't be able to find
project = pagure.lib.query.get_authorized_project(self.session, 'test')
msg = pagure.lib.query.new_issue(
session=self.session,
repo=project,
title='Test issue',
content='We should work on this',
user='******',
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue')
project = pagure.lib.query.get_authorized_project(
self.session, 'test2')
msg = pagure.lib.query.new_issue(
session=self.session,
repo=project,
title='Test issue on test2',
content='We should work on this, really',
user='******',
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue on test2')
# Create a fork of test for foo with its own ticket
item = pagure.lib.model.Project(
user_id=2, # foo
name='test',
is_fork=True,
parent_id=1,
description='test project #1',
hook_token='aaabbbccc_foo',
)
item.close_status = [
'Invalid', 'Insufficient data', 'Fixed', 'Duplicate'
]
self.session.add(item)
self.session.commit()
project = pagure.lib.query.get_authorized_project(self.session,
'test',
user="******")
msg = pagure.lib.query.new_issue(
session=self.session,
repo=project,
title='Test issue on fork/foo/test',
content='We should work on this, really',
user='******',
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue on fork/foo/test')
self.folder = os.path.join(self.path, 'repos', 'test.git')
# Add a README to the git repo - First commit
tests.add_readme_git_repo(self.folder)
def insert_data(session, username, user_email):
_config['EMAIL_SEND'] = False
_config['TESTING'] = True
# Populate with default statuses
create_default_status(session)
print('Default statuses populated')
######################################
# tags
item = pagure.lib.model.Tag(tag='tag1', )
session.add(item)
session.commit()
######################################
# Users
# Create a couple of users
pingou = item = pagure.lib.model.User(
user='******',
fullname='PY C',
password=generate_hashed_value(u'testing123'),
token=None,
default_email='*****@*****.**',
)
session.add(item)
session.commit()
print("User created: {} <{}>, {}".format(item.user, item.default_email,
'testing123'))
foo = item = pagure.lib.model.User(
user='******',
fullname='foo bar',
password=generate_hashed_value(u'testing123'),
token=None,
default_email='*****@*****.**',
)
session.add(item)
session.commit()
print("User created: {} <{}>, {}".format(item.user, item.default_email,
'testing123'))
you = item = pagure.lib.model.User(
user=username,
fullname=username,
password=generate_hashed_value(u'testing123'),
token=None,
default_email=user_email,
)
session.add(item)
session.commit()
print("User created: {} <{}>, {}".format(item.user, item.default_email,
'testing123'))
######################################
# pagure_group
item = pagure.lib.model.PagureGroup(
group_name='admin',
group_type='admin',
user_id=pingou.id,
display_name='admin',
description='Admin Group',
)
session.add(item)
session.commit()
print('Created "admin" group. Pingou is a member.')
# Add a couple of groups so that we can list them
item = pagure.lib.model.PagureGroup(
group_name='group',
group_type='user',
user_id=pingou.id,
display_name='group group',
description='this is a group group',
)
session.add(item)
session.commit()
print('Created "group" group. Pingou is a member.')
item = pagure.lib.model.PagureGroup(
group_name='rel-eng',
group_type='user',
user_id=pingou.id,
display_name='Release Engineering',
description='The group of release engineers',
)
session.add(item)
session.commit()
print('Created "rel-eng" group. Pingou is a member.')
######################################
# projects
import shutil
# delete folder from local instance to start from a clean slate
if os.path.exists(_config['GIT_FOLDER']):
shutil.rmtree(_config['GIT_FOLDER'])
# Create projects
item = project1 = pagure.lib.model.Project(
user_id=pingou.id,
name='test',
is_fork=False,
parent_id=None,
description='test project #1',
hook_token='aaabbbccc',
)
item.close_status = ['Invalid', 'Insufficient data', 'Fixed', 'Duplicate']
session.add(item)
session.flush()
tests.create_locks(session, item)
item = project2 = pagure.lib.model.Project(
user_id=pingou.id,
name='test2',
is_fork=False,
parent_id=None,
description='test project #2',
hook_token='aaabbbddd',
)
item.close_status = ['Invalid', 'Insufficient data', 'Fixed', 'Duplicate']
session.add(item)
item = project3 = pagure.lib.model.Project(
user_id=pingou.id,
name='test3',
is_fork=False,
parent_id=None,
description='namespaced test project',
hook_token='aaabbbeee',
namespace='somenamespace',
)
item.close_status = ['Invalid', 'Insufficient data', 'Fixed', 'Duplicate']
session.add(item)
session.commit()
tests.create_projects_git(_config['GIT_FOLDER'], bare=True)
add_content_git_repo(os.path.join(_config['GIT_FOLDER'], 'test.git'))
tests.add_readme_git_repo(os.path.join(_config['GIT_FOLDER'], 'test.git'))
# Add some content to the git repo
add_content_git_repo(
os.path.join(_config['GIT_FOLDER'], 'forks', 'pingou', 'test.git'))
tests.add_readme_git_repo(
os.path.join(_config['GIT_FOLDER'], 'forks', 'pingou', 'test.git'))
tests.add_commit_git_repo(os.path.join(_config['GIT_FOLDER'], 'forks',
'pingou', 'test.git'),
ncommits=10)
######################################
# user_emails
item = pagure.lib.model.UserEmail(user_id=pingou.id,
email='*****@*****.**')
session.add(item)
item = pagure.lib.model.UserEmail(user_id=pingou.id,
email='*****@*****.**')
session.add(item)
item = pagure.lib.model.UserEmail(user_id=foo.id, email='*****@*****.**')
session.add(item)
item = pagure.lib.model.UserEmail(user_id=you.id, email=user_email)
session.add(item)
session.commit()
######################################
# user_emails_pending
email_pend = pagure.lib.model.UserEmailPending(
user_id=pingou.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=1001,
uid='foobar',
project_id=project1.id,
title='Problem with jenkins build',
content='For some reason the tests fail at line:24',
user_id=pingou.id,
)
session.add(item)
session.commit()
item = pagure.lib.model.Issue(
id=1002,
uid='foobar2',
project_id=project1.id,
title='Unit tests failing',
content='Need to fix code for the unit tests to '
'pass so jenkins build can complete.',
user_id=pingou.id,
)
session.add(item)
session.commit()
item = pagure.lib.model.Issue(
id=1003,
uid='foobar3',
project_id=project1.id,
title='Segfault during execution',
content='Index out of bounds for variable i?',
user_id=you.id,
)
session.add(item)
session.commit()
######################################
# pagure_user_group
group = pagure.lib.query.search_groups(session,
pattern=None,
group_name="rel-eng",
group_type=None)
item = pagure.lib.model.PagureUserGroup(user_id=pingou.id,
group_id=group.id)
session.add(item)
session.commit()
group = pagure.lib.query.search_groups(session,
pattern=None,
group_name="admin",
group_type=None)
item = pagure.lib.model.PagureUserGroup(user_id=you.id, group_id=group.id)
session.add(item)
session.commit()
group = pagure.lib.query.search_groups(session,
pattern=None,
group_name="group",
group_type=None)
item = pagure.lib.model.PagureUserGroup(user_id=foo.id, group_id=group.id)
session.add(item)
session.commit()
######################################
# projects_groups
group = pagure.lib.query.search_groups(session,
pattern=None,
group_name="rel-eng",
group_type=None)
repo = pagure.lib.query.get_authorized_project(session, 'test')
item = pagure.lib.model.ProjectGroup(project_id=repo.id,
group_id=group.id,
access="commit")
session.add(item)
session.commit()
group = pagure.lib.query.search_groups(session,
pattern=None,
group_name="admin",
group_type=None)
repo = pagure.lib.query.get_authorized_project(session, 'test2')
item = pagure.lib.model.ProjectGroup(project_id=repo.id,
group_id=group.id,
access="admin")
session.add(item)
session.commit()
######################################
# pull_requests
repo = pagure.lib.query.get_authorized_project(session, 'test')
forked_repo = pagure.lib.query.get_authorized_project(session, 'test')
req = pagure.lib.query.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)
session.commit()
######################################
# tokens
tests.create_tokens(session, user_id=pingou.id, project_id=project1.id)
######################################
# user_projects
repo = pagure.lib.query.get_authorized_project(session, 'test')
item = pagure.lib.model.ProjectUser(project_id=repo.id,
user_id=foo.id,
access="commit")
session.add(item)
session.commit()
repo = pagure.lib.query.get_authorized_project(session, 'test2')
item = pagure.lib.model.ProjectUser(project_id=repo.id,
user_id=you.id,
access="commit")
session.add(item)
session.commit()
######################################
# issue_comments
item = pagure.lib.model.IssueComment(
user_id=pingou.id,
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.query.get_authorized_project(session, 'test')
all_issues = pagure.lib.query.search_issues(session, repo)
pagure.lib.query.add_issue_dependency(session, all_issues[0],
all_issues[1], 'pingou')
######################################
# pull_request_comments
user = pagure.lib.query.search_user(session, username='******')
# only 1 pull request available atm
pr = pagure.lib.query.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
# only 1 pull request available atm
pr = pagure.lib.query.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=pingou.id,
username=pingou.user,
percent=80,
comment="Jenkins build passes",
url=str(pr.id),
status="Open")
session.add(item)
session.commit()
######################################
# tags_issues
repo = pagure.lib.query.get_authorized_project(session, 'test')
issues = pagure.lib.query.search_issues(session, repo)
item = pagure.lib.model.TagIssue(
issue_uid=issues[0].uid,
tag='tag1',
)
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(_config['GIT_FOLDER'], fork_proj_location))
except:
print('git folder already deleted')
try:
shutil.rmtree(os.path.join(_config['DOCS_FOLDER'], fork_proj_location))
except:
print('docs folder already deleted')
try:
shutil.rmtree(
os.path.join(_config['TICKETS_FOLDER'], fork_proj_location))
except:
print('tickets folder already deleted')
try:
shutil.rmtree(
os.path.join(_config['REQUESTS_FOLDER'], fork_proj_location))
except:
print('requests folder already deleted')
repo = pagure.lib.query.get_authorized_project(session, 'test')
result = pagure.lib.query.fork_project(session, 'foo', repo)
if result == 'Repo "test" cloned to "foo/test"':
session.commit()
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_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 setUp(self):
super(PagureFlaskApiProjectViewFiletests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
tests.add_readme_git_repo(os.path.join(self.path, "repos", "test.git"))
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 setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureHooksPagureHooktests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
# Add one issue to each projects otherwise we won't be able to find
project = pagure.lib.query.get_authorized_project(self.session, "test")
msg = pagure.lib.query.new_issue(
session=self.session,
repo=project,
title="Test issue",
content="We should work on this",
user="******",
)
self.session.commit()
self.assertEqual(msg.title, "Test issue")
project = pagure.lib.query.get_authorized_project(
self.session, "test2"
)
msg = pagure.lib.query.new_issue(
session=self.session,
repo=project,
title="Test issue on test2",
content="We should work on this, really",
user="******",
)
self.session.commit()
self.assertEqual(msg.title, "Test issue on test2")
# Create a fork of test for foo with its own ticket
item = pagure.lib.model.Project(
user_id=2, # foo
name="test",
is_fork=True,
parent_id=1,
description="test project #1",
hook_token="aaabbbccc_foo",
)
item.close_status = [
"Invalid",
"Insufficient data",
"Fixed",
"Duplicate",
]
self.session.add(item)
self.session.commit()
project = pagure.lib.query.get_authorized_project(
self.session, "test", user="******"
)
msg = pagure.lib.query.new_issue(
session=self.session,
repo=project,
title="Test issue on fork/foo/test",
content="We should work on this, really",
user="******",
)
self.session.commit()
self.assertEqual(msg.title, "Test issue on fork/foo/test")
self.folder = os.path.join(self.path, "repos", "test.git")
# Add a README to the git repo - First commit
tests.add_readme_git_repo(self.folder)
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_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))
