def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiProjectBlockuserTests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
item = pagure.lib.model.Token(
id="aaabbbcccdddeee",
user_id=2,
project_id=1,
expiration=datetime.datetime.utcnow()
+ datetime.timedelta(days=30),
)
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id="aaabbbcccdddeee")
project = pagure.lib.query.get_authorized_project(self.session, "test")
self.assertEqual(project.block_users, [])
self.blocked_users = []
project = pagure.lib.query.get_authorized_project(
self.session, "test2"
)
project.block_users = ["foo"]
self.session.add(project)
self.session.commit()
def setUp(self):
""" Set up the environnment, ran before every tests. """
self.maxDiff = None
super(PagureFlaskApiCustomFieldIssuetests, self).setUp()
pagure.APP.config['TESTING'] = True
pagure.SESSION = self.session
pagure.api.SESSION = self.session
pagure.api.issue.SESSION = self.session
pagure.lib.SESSION = self.session
pagure.APP.config['TICKETS_FOLDER'] = None
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'tickets'))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create normal issue
repo = pagure.get_authorized_project(self.session, 'test')
pagure.lib.new_issue(
session=self.session,
repo=repo,
title='Test issue #1',
content='We should work on this',
user='******',
ticketfolder=None,
private=False,
)
self.session.commit()
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiProjectUpdateWatchTests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'tickets'))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create normal issue
repo = pagure.lib.query.get_authorized_project(self.session, 'test')
msg = pagure.lib.query.new_issue(
session=self.session,
repo=repo,
title='Test issue #1',
content='We should work on this',
user='******',
private=False,
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue #1')
# Create project-less token for user foo
item = pagure.lib.model.Token(id='project-less-foo',
user_id=1,
project_id=None,
expiration=datetime.datetime.utcnow() +
datetime.timedelta(days=30))
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id='project-less-foo')
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiGetPRFlagtests, self).setUp()
pagure.config.config["REQUESTS_FOLDER"] = None
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create a pull-request
repo = pagure.lib.query.get_authorized_project(self.session, "test")
forked_repo = pagure.lib.query.get_authorized_project(
self.session, "test"
)
req = pagure.lib.query.new_pull_request(
session=self.session,
repo_from=forked_repo,
branch_from="master",
repo_to=repo,
branch_to="master",
title="test pull-request",
user="******",
)
self.session.commit()
self.assertEqual(req.id, 1)
self.assertEqual(req.title, "test pull-request")
# Check flags before
self.session.commit()
request = pagure.lib.query.search_pull_requests(
self.session, project_id=1, requestid=1
)
self.assertEqual(len(request.flags), 0)
def test_http_push(self):
""" Test that the HTTP push endpoint works for repoSpanner. """
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
self.create_project_full("clonetest", {"create_readme": "y"})
# Verify the new project is indeed on repoSpanner
project = pagure.lib.query._get_project(self.session, "clonetest")
self.assertTrue(project.is_on_repospanner)
# Unfortunately, actually testing a git clone would need the app to
# run on a TCP port, which the test environment doesn't do.
output = self.app.get(
"/clonetest.git/info/refs?service=git-receive-pack",
environ_overrides={"REMOTE_USER": "******"},
)
self.assertEqual(output.status_code, 200)
self.assertEqual(
output.content_type, "application/x-git-receive-pack-advertisement"
)
output_text = output.get_data(as_text=True)
self.assertIn("# service=git-receive-pack", output_text)
self.assertIn("agent=repoSpanner", output_text)
self.assertIn("symref=HEAD:refs/heads/master", output_text)
self.assertIn(" refs/heads/master\x00", output_text)
def test_api_comment_issue_private_project_less(self):
""" Test the api_comment_issue method of the flask api. """
# Create token for user foo
item = pagure.lib.model.Token(
id="foo_token2",
user_id=2,
project_id=None,
expiration=datetime.datetime.utcnow()
+ datetime.timedelta(days=30),
)
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id="foo_token2")
data = {"comment": "This is a very interesting question"}
headers = {"Authorization": "token foo_token2"}
# Valid request and authorized
output = self.app.post(
"/api/0/test/issue/2/comment", data=data, headers=headers
)
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
data["avatar_url"] = "https://seccdn.libravatar.org/avatar/..."
self.assertDictEqual(
data,
{
"message": "Comment added",
"avatar_url": "https://seccdn.libravatar.org/avatar/...",
"user": "******",
},
)
def setUp(self):
super(PagureLibGitAuthPagureGitAuthtests, self).setUp()
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
self.create_project_full("acltest")
project = pagure.lib.query._get_project(self.session, "acltest")
# Create non-push deploy key
non_push_dkey = 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(non_push_dkey)
# Create push deploy key
push_dkey = pagure.lib.model.SSHKey(
project_id=project.id,
pushaccess=True,
public_ssh_key="\n bar foo",
ssh_short_key="\n bar foo",
ssh_search_key="\n bar foo",
creator_user_id=1, # pingou
)
self.session.add(push_dkey)
self.session.commit()
def setUp(self):
super(PagureFlaskAppClonetests, self).setUp()
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
self.create_project_full("clonetest", {"create_readme": "y"})
def test_rebase_api_api_logged_in(self):
""" Test the rebase PR API endpoint when using an API token and
its outcome. """
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token aaabbbcccddd'}
output = self.app.post('/api/0/test/pull-request/1/rebase',
headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
self.assertEqual(data, {u'message': u'Pull-request rebased'})
user = tests.FakeUser(username='******')
with tests.user_set(self.app.application, user):
data = {
'requestid': self.request.uid,
'csrf_token': self.get_csrf()
}
output = self.app.post('/pv/pull-request/merge', data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
self.assertEqual(
data, {
u'code': u'FFORWARD',
u'message': u'The pull-request can be merged and '
u'fast-forwarded',
u'short_code': u'Ok'
})
def setUp(self):
super(PagureLibGitAuthtests, self).setUp()
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
self.create_project_full('hooktest')
def test_auth(self):
""" Test the token based authentication.
"""
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
output = self.app.post('/api/0/test/new_issue')
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit " \
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK",
}
)
headers = {'Authorization': 'token aaabbbcccddd'}
output = self.app.post('/api/0/test/new_issue', headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data, {
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
})
def test_auth(self):
""" Test the token based authentication.
"""
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_acls(self.session)
tests.create_tokens_acl(self.session)
output = self.app.post("/api/0/test/new_issue")
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit "
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK",
},
)
headers = {"Authorization": "token aaabbbcccddd"}
output = self.app.post("/api/0/test/new_issue", headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(data, {"error": "Invalid or incomplete input submited", "error_code": "EINVALIDREQ"})
def test_auth(self):
""" Test the token based authentication.
"""
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
output = self.app.post('/api/0/test/new_issue')
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertEqual(pagure.api.APIERROR.EINVALIDTOK.name,
data['error_code'])
self.assertEqual(pagure.api.APIERROR.EINVALIDTOK.value, data['error'])
headers = {'Authorization': 'token aaabbbcccddd'}
output = self.app.post('/api/0/test/new_issue', headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
"errors": {
"issue_content": ["This field is required."],
"title": ["This field is required."]
}
}
)
def test_http_push(self):
""" Test that the HTTP push endpoint works for repoSpanner. """
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
self.create_project_full("clonetest", {"create_readme": "y"})
# Verify the new project is indeed on repoSpanner
project = pagure.lib.query._get_project(self.session, "clonetest")
self.assertTrue(project.is_on_repospanner)
# Unfortunately, actually testing a git clone would need the app to
# run on a TCP port, which the test environment doesn't do.
output = self.app.get(
"/clonetest.git/info/refs?service=git-receive-pack",
environ_overrides={"REMOTE_USER": "******"},
)
self.assertEqual(output.status_code, 200)
self.assertEqual(
output.content_type, "application/x-git-receive-pack-advertisement"
)
output_text = output.get_data(as_text=True)
self.assertIn("# service=git-receive-pack", output_text)
self.assertIn("agent=repoSpanner", output_text)
self.assertIn("symref=HEAD:refs/heads/master", output_text)
self.assertIn(" refs/heads/master\x00", output_text)
def test_rebase_api_api_logged_in(self):
""" Test the rebase PR API endpoint when using an API token and
its outcome. """
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {"Authorization": "token aaabbbcccddd"}
output = self.app.post(
"/api/0/test/pull-request/1/rebase", headers=headers
)
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
self.assertEqual(data, {"message": "Pull-request rebased"})
user = tests.FakeUser(username="******")
with tests.user_set(self.app.application, user):
data = {
"requestid": self.request.uid,
"csrf_token": self.get_csrf(),
}
output = self.app.post("/pv/pull-request/merge", data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
self.assertEqual(
data,
{
"code": "FFORWARD",
"message": "The pull-request can be merged and "
"fast-forwarded",
"short_code": "Ok",
},
)
def test_api_comment_issue_private_project_less(self):
""" Test the api_comment_issue method of the flask api. """
# Create token for user foo
item = pagure.lib.model.Token(id='foo_token2',
user_id=2,
project_id=None,
expiration=datetime.datetime.utcnow() +
datetime.timedelta(days=30))
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id='foo_token2')
data = {
'comment': 'This is a very interesting question',
}
headers = {'Authorization': 'token foo_token2'}
# Valid request and authorized
output = self.app.post('/api/0/test/issue/2/comment',
data=data,
headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(data, {'message': 'Comment added'})
def test_auth(self):
""" Test the token based authentication.
"""
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
output = self.app.post('/api/0/test/new_issue')
self.assertEqual(output.status_code, 401)
data = json.loads(output.get_data(as_text=True))
self.assertEqual(pagure.api.APIERROR.EINVALIDTOK.name,
data['error_code'])
self.assertEqual(pagure.api.APIERROR.EINVALIDTOK.value, data['error'])
headers = {'Authorization': 'token aaabbbcccddd'}
output = self.app.post('/api/0/test/new_issue', headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(
data, {
"error": "Invalid or incomplete input submitted",
"error_code": "EINVALIDREQ",
"errors": {
"issue_content": ["This field is required."],
"title": ["This field is required."]
}
})
def test_api_issue_update_no_input(self):
""" Test the api_issue_update method of flask API """
tests.create_tokens_acl(self.session)
tests.create_projects_git(os.path.join(self.path, "tickets"))
headers = {"Authorization": "token aaabbbcccddd"}
# Create an issue
repo = pagure.lib.query.get_authorized_project(self.session, "test")
msg = pagure.lib.query.new_issue(
session=self.session,
repo=repo,
title="Test issue #1",
content="We should work on this",
user="******",
private=False,
)
self.session.commit()
self.assertEqual(msg.title, "Test issue #1")
headers = {"Authorization": "token aaabbbcccddd"}
output = self.app.post("/api/0/test/issue/1", headers=headers)
self.assertEqual(output.status_code, 400)
expected_rv = {
"error": "Invalid or incomplete input submitted",
"error_code": "EINVALIDREQ",
"errors": {
"issue_content": ["This field is required."],
"title": ["This field is required."],
},
}
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(data, expected_rv)
def test_api_issue_update(self):
""" Test the api_issue_update method of flask API """
tests.create_tokens_acl(self.session)
tests.create_projects_git(os.path.join(self.path, "tickets"))
headers = {"Authorization": "token aaabbbcccddd"}
# Create an issue
repo = pagure.lib.query.get_authorized_project(self.session, "test")
msg = pagure.lib.query.new_issue(
session=self.session,
repo=repo,
title="Test issue #1",
content="We should work on this",
user="******",
private=False,
)
self.session.commit()
self.assertEqual(msg.title, "Test issue #1")
headers = {"Authorization": "token aaabbbcccddd"}
data = {"title": "New title", "issue_content": "New content"}
output = self.app.post("/api/0/test/issue/1",
data=data,
headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
self.assertEqual(data["message"], "Issue edited")
self.assertEqual(data["issue"]["title"], "New title")
self.assertEqual(data["issue"]["content"], "New content")
output = self.app.get("/api/0/test/issue/1", headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
self.assertEqual(data["title"], "New title")
self.assertEqual(data["content"], "New content")
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiProjectUpdateWatchTests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "tickets"))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create normal issue
repo = pagure.lib.query.get_authorized_project(self.session, "test")
msg = pagure.lib.query.new_issue(
session=self.session,
repo=repo,
title="Test issue #1",
content="We should work on this",
user="******",
private=False,
)
self.session.commit()
self.assertEqual(msg.title, "Test issue #1")
# Create project-less token for user foo
item = pagure.lib.model.Token(
id="project-less-foo",
user_id=1,
project_id=None,
expiration=datetime.datetime.utcnow()
+ datetime.timedelta(days=30),
)
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id="project-less-foo")
def test_api_project_tags_new(self):
""" Test the api_tags_new method of the flask api. """
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {"Authorization": "token aaabbbcccddd"}
output = self.app.get("/api/0/test/tags/")
self.assertEqual(output.status_code, 200)
expected_rv = {"tags": [], "total_tags": 0}
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(data, expected_rv)
data = {"tag": "blue", "tag_color": "DeepBlueSky"}
output = self.app.post("/api/0/test/tags/new",
headers=headers,
data=data)
self.assertEqual(output.status_code, 200)
expected_rv = {
"message": "Tag created",
"tag": {
"tag": "blue",
"tag_description": "",
"tag_color": "DeepBlueSky",
},
}
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(data, expected_rv)
output = self.app.get("/api/0/test/tags/")
self.assertEqual(output.status_code, 200)
expected_rv = {"tags": ["blue"], "total_tags": 1}
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(data, expected_rv)
def setUp(self):
super(PagureLibGitAuthtests, self).setUp()
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
self.create_project_full("hooktest")
def setUp(self):
super(PagureLibGitAuthPagureGitAuthtests, self).setUp()
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
self.create_project_full("acltest")
project = pagure.lib.query._get_project(self.session, "acltest")
# Create non-push deploy key
non_push_dkey = 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(non_push_dkey)
# Create push deploy key
push_dkey = pagure.lib.model.SSHKey(
project_id=project.id,
pushaccess=True,
public_ssh_key="\n bar foo",
ssh_short_key="\n bar foo",
ssh_search_key="\n bar foo",
creator_user_id=1, # pingou
)
self.session.add(push_dkey)
self.session.commit()
def test_api_project_tag_delete(self):
""" Test the api_project_tag_delete method of flask api. """
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
item = pagure.lib.model.TagColored(tag="blue",
tag_color="DeepBlueSky",
project_id=1)
self.session.add(item)
self.session.commit()
output = self.app.get("/api/0/test/tags/")
self.assertEqual(output.status_code, 200)
expected_rv = {"tags": ["blue"], "total_tags": 1}
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(data, expected_rv)
headers = {"Authorization": "token aaabbbcccddd"}
output = self.app.delete("/api/0/test/tag/blue", headers=headers)
self.assertEqual(output.status_code, 200)
expected_rv = {"message": "Tag: blue has been deleted"}
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(data, expected_rv)
output = self.app.get("/api/0/test/tags/")
self.assertEqual(output.status_code, 200)
expected_rv = {"tags": [], "total_tags": 0}
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(data, expected_rv)
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiPRFlagUserTokentests, self).setUp()
pagure.config.config['REQUESTS_FOLDER'] = None
tests.create_projects(self.session)
tests.create_tokens(self.session, project_id=None)
tests.create_tokens_acl(self.session)
# Create a pull-request
repo = pagure.lib.query.get_authorized_project(self.session, 'test')
forked_repo = pagure.lib.query.get_authorized_project(self.session, 'test')
req = pagure.lib.query.new_pull_request(
session=self.session,
repo_from=forked_repo,
branch_from='master',
repo_to=repo,
branch_to='master',
title='test pull-request',
user='******',
)
self.session.commit()
self.assertEqual(req.id, 1)
self.assertEqual(req.title, 'test pull-request')
# Check flags before
self.session.commit()
request = pagure.lib.query.search_pull_requests(
self.session, project_id=1, requestid=1)
self.assertEqual(len(request.flags), 0)
def setUp(self):
super(PagureFlaskAppClonetests, self).setUp()
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
self.create_project_full('clonetest', {"create_readme": "y"})
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiProjectBlockuserTests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
item = pagure.lib.model.Token(
id="aaabbbcccdddeee",
user_id=2,
project_id=1,
expiration=datetime.datetime.utcnow() +
datetime.timedelta(days=30),
)
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id="aaabbbcccdddeee")
project = pagure.lib.query.get_authorized_project(self.session, "test")
self.assertEqual(project.block_users, [])
self.blocked_users = []
project = pagure.lib.query.get_authorized_project(
self.session, "test2")
project.block_users = ["foo"]
self.session.add(project)
self.session.commit()
def test_http_pull(self):
""" Test that the HTTP pull endpoint works for repoSpanner. """
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
self.create_project_full('clonetest', {"create_readme": "y"})
# Verify the new project is indeed on repoSpanner
project = pagure.lib.query._get_project(self.session, 'clonetest')
self.assertTrue(project.is_on_repospanner)
# Unfortunately, actually testing a git clone would need the app to
# run on a TCP port, which the test environment doesn't do.
output = self.app.get(
'/clonetest.git/info/refs?service=git-upload-pack')
self.assertEqual(output.status_code, 200)
output_text = output.get_data(as_text=True)
self.assertIn("# service=git-upload-pack", output_text)
self.assertIn("symref=HEAD:refs/heads/master", output_text)
self.assertIn(" refs/heads/master\x00", output_text)
output = self.app.post(
'/clonetest.git/git-upload-pack',
headers={'Content-Type': 'application/x-git-upload-pack-request'},
)
self.assertEqual(output.status_code, 400)
output_text = output.get_data(as_text=True)
self.assertIn("Error processing your request", 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 test_rebase_api_api_logged_in(self):
""" Test the rebase PR API endpoint when using an API token and
its outcome. """
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {"Authorization": "token aaabbbcccddd"}
output = self.app.post(
"/api/0/test/pull-request/1/rebase", headers=headers
)
self.assertEqual(output.status_code, 403)
data = json.loads(output.get_data(as_text=True))
self.assertEqual(
data,
{
"error": "You are not authorized to rebase this pull-request",
"error_code": "EREBASENOTALLOWED",
},
)
# Add pingou to fork repo so he can rebase while allow_rebase = False
fork = pagure.lib.query.get_authorized_project(
self.session, "test", user="******"
)
msg = pagure.lib.query.add_user_to_project(
session=self.session, project=fork, new_user="******", user="******"
)
self.session.commit()
self.assertEqual(msg, "User added")
output = self.app.post(
"/api/0/test/pull-request/1/rebase", headers=headers
)
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
self.assertEqual(data, {"message": "Pull-request rebased"})
user = tests.FakeUser(username="******")
with tests.user_set(self.app.application, user):
data = {
"requestid": self.request.uid,
"csrf_token": self.get_csrf(),
}
output = self.app.post("/pv/pull-request/merge", data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.get_data(as_text=True))
self.assertEqual(
data,
{
"code": "FFORWARD",
"message": "The pull-request can be merged and "
"fast-forwarded",
"short_code": "Ok",
},
)
def test_api_issue_update_wrong_issue(self):
""" Test the api_issue_update method of flask API """
tests.create_tokens_acl(self.session)
tests.create_projects_git(os.path.join(self.path, "tickets"))
headers = {"Authorization": "token aaabbbcccddd"}
output = self.app.post("/api/0/test/issue/1", headers=headers)
self.assertEqual(output.status_code, 404)
expected_rv = {"error": "Issue not found", "error_code": "ENOISSUE"}
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(data, expected_rv)
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 setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiIssueCommenttests, self).setUp()
pagure.APP.config['TESTING'] = True
pagure.SESSION = self.session
pagure.api.SESSION = self.session
pagure.api.issue.SESSION = self.session
pagure.lib.SESSION = self.session
pagure.APP.config['TICKETS_FOLDER'] = None
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'tickets'))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create normal issue
repo = pagure.get_authorized_project(self.session, 'test')
msg = pagure.lib.new_issue(
session=self.session,
repo=repo,
title='Test issue #1',
content='We should work on this',
user='******',
ticketfolder=None,
private=False,
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue #1')
# Create private issue
msg = pagure.lib.new_issue(
session=self.session,
repo=repo,
title='Test issue #2',
content='We should work on this',
user='******',
ticketfolder=None,
private=True,
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue #2')
# Create project-less token for user foo
item = pagure.lib.model.Token(id='project-less-foo',
user_id=2,
project_id=None,
expiration=datetime.datetime.utcnow() +
datetime.timedelta(days=30))
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id='project-less-foo')
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiProjectGitTagstests, self).setUp()
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
tests.add_commit_git_repo(
folder=os.path.join(self.path, "repos", "test.git"))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# token for user = pingou (user_id = 1)
self.headers = {"Authorization": "token aaabbbcccddd"}
def test_api_issue_update_instance_tickets_disabled(self):
""" Test the api_issue_update method of flask API """
tests.create_tokens_acl(self.session)
headers = {"Authorization": "token aaabbbcccddd"}
output = self.app.post("/api/0/test/issue/1", headers=headers)
self.assertEqual(output.status_code, 404)
expected_rv = {
"error": "Issue tracker disabled",
"error_code": "ETRACKERDISABLED",
}
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(data, expected_rv)
def test_api_project_tag_delete_wrong_tag(self):
""" Test the api_project_tag_delete method of flask api. """
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {"Authorization": "token aaabbbcccddd"}
output = self.app.delete("/api/0/test/tag/blue", headers=headers)
self.assertEqual(output.status_code, 404)
expected_rv = {"error": "Tag not found", "error_code": "ENOTAG"}
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(data, expected_rv)
def test_api_issue_update_wrong_project(self):
""" Test the api_issue_update method of flask API """
tests.create_tokens_acl(self.session)
headers = {"Authorization": "token aaabbbcccddd"}
output = self.app.post("/api/0/foo/issue/1", headers=headers)
self.assertEqual(output.status_code, 404)
expected_rv = {
"error": "Project not found",
"error_code": "ENOPROJECT",
}
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(data, expected_rv)
def test_api_new_issue(self):
""" Test the api_new_issue method of the flask api. """
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(tests.HERE, "tickets"))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {"Authorization": "token aaabbbcccddd"}
# Valid token, wrong project
output = self.app.post("/api/0/test2/new_issue", headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit "
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK",
},
)
# No input
output = self.app.post("/api/0/test/new_issue", headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(data, {"error": "Invalid or incomplete input submited", "error_code": "EINVALIDREQ"})
data = {"title": "test issue"}
# Invalid repo
output = self.app.post("/api/0/foo/new_issue", data=data, headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(data, {"error": "Project not found", "error_code": "ENOPROJECT"})
# Incomplete request
output = self.app.post("/api/0/test/new_issue", data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(data, {"error": "Invalid or incomplete input submited", "error_code": "EINVALIDREQ"})
data = {"title": "test issue", "issue_content": "This issue needs attention"}
# Valid request
output = self.app.post("/api/0/test/new_issue", data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(data, {"message": "Issue created"})
def test_api_project_tag_view_wrong_tag(self):
""" Test the api_project_tag_view method of the flask api. """
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
item = pagure.lib.model.TagColored(tag="blue",
tag_color="DeepBlueSky",
project_id=1)
self.session.add(item)
self.session.commit()
output = self.app.get("/api/0/test/tag/tag1")
self.assertEqual(output.status_code, 404)
expected_rv = {"error": "Tag not found", "error_code": "ENOTAG"}
data = json.loads(output.get_data(as_text=True))
self.assertDictEqual(data, expected_rv)
def test_rebase_api_api_logged_in_unknown_pr(self):
""" Test the rebase PR API endpoint when the PR doesn't exist """
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {"Authorization": "token aaabbbcccddd"}
output = self.app.post(
"/api/0/test/pull-request/404/rebase", headers=headers
)
self.assertEqual(output.status_code, 404)
data = json.loads(output.get_data(as_text=True))
self.assertEqual(
data, {"error": "Pull-Request not found", "error_code": "ENOREQ"}
)
def test_api_new_project_user_ns(self, p_gga):
""" Test the api_new_project method of the flask api. """
pagure.APP.config['USER_NAMESPACE'] = True
p_gga.return_value = True
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'tickets'))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token aaabbbcccddd'}
# Create a project with the user namespace feature on
data = {
'name': 'testproject',
'description': 'Just another small test project',
}
# Valid request
output = self.app.post(
'/api/0/new/', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Project "pingou/testproject" created'}
)
# Create a project with a namespace and the user namespace feature on
pagure.APP.config['ALLOWED_PREFIX'] = ['testns']
data = {
'name': 'testproject2',
'namespace': 'testns',
'description': 'Just another small test project',
}
# Valid request
output = self.app.post(
'/api/0/new/', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Project "testns/testproject2" created'}
)
pagure.APP.config['USER_NAMESPACE'] = False
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureFlaskApiIssueCreatetests, self).setUp()
pagure.config.config["TICKETS_FOLDER"] = None
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "tickets"))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create project-less token for user foo
item = pagure.lib.model.Token(
id="project-less-foo",
user_id=2,
project_id=None,
expiration=datetime.datetime.utcnow()
+ datetime.timedelta(days=30),
)
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id="project-less-foo")
# Create project-specific token for user foo
item = pagure.lib.model.Token(
id="project-specific-foo",
user_id=2,
project_id=1,
expiration=datetime.datetime.utcnow()
+ datetime.timedelta(days=30),
)
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id="project-specific-foo")
def setUp(self):
""" Set up the environnment, ran before every tests. """
self.maxDiff = None
super(PagureFlaskApiCustomFieldIssuetests, self).setUp()
pagure.config.config["TICKETS_FOLDER"] = None
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, "tickets"))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create normal issue
repo = pagure.lib.query.get_authorized_project(self.session, "test")
pagure.lib.query.new_issue(
session=self.session,
repo=repo,
title="Test issue #1",
content="We should work on this",
user="******",
private=False,
)
self.session.commit()
def test_api_pull_request_views(self, send_email):
""" Test the api_pull_request_views method of the flask api. """
send_email.return_value = True
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create a pull-request
repo = pagure.lib.get_project(self.session, 'test')
forked_repo = pagure.lib.get_project(self.session, 'test')
req = pagure.lib.new_pull_request(
session=self.session,
repo_from=forked_repo,
branch_from='master',
repo_to=repo,
branch_to='master',
title='test pull-request',
user='******',
requestfolder=None,
)
self.session.commit()
self.assertEqual(req.id, 1)
self.assertEqual(req.title, 'test pull-request')
# Invalid repo
output = self.app.get('/api/0/foo/pull-requests')
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Project not found",
"error_code": "ENOPROJECT",
}
)
# List pull-requests
output = self.app.get('/api/0/test/pull-requests')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
data['requests'][0]['date_created'] = '1431414800'
data['requests'][0]['updated_on'] = '1431414800'
data['requests'][0]['project']['date_created'] = '1431414800'
data['requests'][0]['repo_from']['date_created'] = '1431414800'
data['requests'][0]['uid'] = '1431414800'
self.assertDictEqual(
data,
{
"args": {
"assignee": None,
"author": None,
"status": True
},
"total_requests": 1,
"requests": [
{
"assignee": None,
"branch": "master",
"branch_from": "master",
"closed_at": None,
"closed_by": None,
"comments": [],
"commit_start": None,
"commit_stop": None,
"date_created": "1431414800",
"id": 1,
"initial_comment": None,
"project": {
"date_created": "1431414800",
"description": "test project #1",
"id": 1,
"name": "test",
"parent": None,
"priorities": {},
"tags": [],
"user": {
"fullname": "PY C",
"name": "pingou"
}
},
"remote_git": None,
"repo_from": {
"date_created": "1431414800",
"description": "test project #1",
"id": 1,
"name": "test",
"parent": None,
"priorities": {},
"tags": [],
"user": {
"fullname": "PY C",
"name": "pingou"
}
},
"status": 'Open',
"title": "test pull-request",
"uid": "1431414800",
"updated_on": "1431414800",
"user": {
"fullname": "PY C",
"name": "pingou"
}
}
]
}
)
headers = {'Authorization': 'token aaabbbcccddd'}
# Access Pull-Request authenticated
output = self.app.get('/api/0/test/pull-requests', headers=headers)
self.assertEqual(output.status_code, 200)
data2 = json.loads(output.data)
data2['requests'][0]['date_created'] = '1431414800'
data2['requests'][0]['updated_on'] = '1431414800'
data2['requests'][0]['project']['date_created'] = '1431414800'
data2['requests'][0]['repo_from']['date_created'] = '1431414800'
data2['requests'][0]['uid'] = '1431414800'
self.assertDictEqual(data, data2)
def test_api_comment_issue(self, p_send_email, p_ugt):
""" Test the api_comment_issue method of the flask api. """
p_send_email.return_value = True
p_ugt.return_value = True
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_acls(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token aaabbbcccddd'}
# Invalid project
output = self.app.post('/api/0/foo/issue/1/comment', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Project not found",
"error_code": "ENOPROJECT",
}
)
# Valid token, wrong project
output = self.app.post('/api/0/test2/issue/1/comment', headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit " \
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK",
}
)
# No input
output = self.app.post('/api/0/test/issue/1/comment', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Issue not found",
"error_code": "ENOISSUE",
}
)
# Create normal issue
repo = pagure.lib.get_project(self.session, 'test')
msg = pagure.lib.new_issue(
session=self.session,
repo=repo,
title='Test issue #1',
content='We should work on this',
user='******',
ticketfolder=None,
private=False,
issue_uid='aaabbbccc#1',
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue #1')
# Check comments before
repo = pagure.lib.get_project(self.session, 'test')
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(len(issue.comments), 0)
data = {
'title': 'test issue',
}
# Incomplete request
output = self.app.post(
'/api/0/test/issue/1/comment', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
}
)
# No change
repo = pagure.lib.get_project(self.session, 'test')
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(issue.status, 'Open')
data = {
'comment': 'This is a very interesting question',
}
# Valid request
output = self.app.post(
'/api/0/test/issue/1/comment', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Comment added'}
)
# One comment added
repo = pagure.lib.get_project(self.session, 'test')
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(len(issue.comments), 1)
# Create another project
item = pagure.lib.model.Project(
user_id=2, # foo
name='foo',
description='test project #3',
hook_token='aaabbbdddeee',
)
self.session.add(item)
self.session.commit()
# Create a token for pingou for this project
item = pagure.lib.model.Token(
id='pingou_foo',
user_id=1,
project_id=3,
expiration=datetime.datetime.utcnow() + datetime.timedelta(
days=30)
)
self.session.add(item)
self.session.commit()
# Give `change_status_issue` to this token
item = pagure.lib.model.TokenAcl(
token_id='pingou_foo',
acl_id=5,
)
self.session.add(item)
self.session.commit()
repo = pagure.lib.get_project(self.session, 'foo')
# Create private issue
msg = pagure.lib.new_issue(
session=self.session,
repo=repo,
title='Test issue',
content='We should work on this',
user='******',
ticketfolder=None,
private=True,
issue_uid='aaabbbccc#2',
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue')
# Check before
repo = pagure.lib.get_project(self.session, 'foo')
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(len(issue.comments), 0)
data = {
'comment': 'This is a very interesting question',
}
headers = {'Authorization': 'token pingou_foo'}
# Valid request but un-authorized
output = self.app.post(
'/api/0/foo/issue/1/comment', data=data, headers=headers)
self.assertEqual(output.status_code, 403)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "You are not allowed to view this issue",
"error_code": "EISSUENOTALLOWED",
}
)
# No comment added
repo = pagure.lib.get_project(self.session, 'foo')
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(len(issue.comments), 0)
# Create token for user foo
item = pagure.lib.model.Token(
id='foo_token2',
user_id=2,
project_id=3,
expiration=datetime.datetime.utcnow() + datetime.timedelta(days=30)
)
self.session.add(item)
self.session.commit()
tests.create_tokens_acl(self.session, token_id='foo_token2')
data = {
'comment': 'This is a very interesting question',
}
headers = {'Authorization': 'token foo_token2'}
# Valid request and authorized
output = self.app.post(
'/api/0/foo/issue/1/comment', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Comment added'}
)
def test_api_fork_project(self, p_gga):
""" Test the api_fork_project method of the flask api. """
p_gga.return_value = True
tests.create_projects(self.session)
for folder in ['docs', 'tickets', 'requests', 'repos']:
tests.create_projects_git(
os.path.join(tests.HERE, folder), bare=True)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token foo_token'}
# Invalid token
output = self.app.post('/api/0/fork', headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit " \
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK"
}
)
headers = {'Authorization': 'token aaabbbcccddd'}
# No input
output = self.app.post('/api/0/fork', headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
}
)
data = {
'name': 'test',
}
# Incomplete request
output = self.app.post(
'/api/0/fork', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
}
)
data = {
'repo': 'test',
}
# Valid request
output = self.app.post(
'/api/0/fork/', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"message": "Repo \"test\" cloned to \"pingou/test\""
}
)
data = {
'repo': 'test',
}
# project already forked
output = self.app.post(
'/api/0/fork/', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Repo \"forks/pingou/test\" already exists",
"error_code": "ENOCODE"
}
)
data = {
'repo': 'test',
'username': '******',
}
# Fork already exists
output = self.app.post(
'/api/0/fork/', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Repo \"forks/pingou/test\" already exists",
"error_code": "ENOCODE"
}
)
def test_api_new_project(self, p_gga):
""" Test the api_new_project method of the flask api. """
p_gga.return_value = True
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(self.path, 'tickets'))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token foo_token'}
# Invalid token
output = self.app.post('/api/0/new', headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertEqual(pagure.api.APIERROR.EINVALIDTOK.name,
data['error_code'])
self.assertEqual(pagure.api.APIERROR.EINVALIDTOK.value, data['error'])
headers = {'Authorization': 'token aaabbbcccddd'}
# No input
output = self.app.post('/api/0/new', headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
"errors": {
"name": ["This field is required."],
"description": ["This field is required."]
}
}
)
data = {
'name': 'test',
}
# Incomplete request
output = self.app.post(
'/api/0/new', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
"errors": {"description": ["This field is required."]}
}
)
data = {
'name': 'test',
'description': 'Just a small test project',
}
# Valid request but repo already exists
output = self.app.post(
'/api/0/new/', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "The tickets repo \"test.git\" already exists",
"error_code": "ENOCODE"
}
)
data = {
'name': 'test_42',
'description': 'Just another small test project',
}
# Valid request
output = self.app.post(
'/api/0/new/', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Project "test_42" created'}
)
def test_api_change_status_issue(self):
""" Test the api_change_status_issue method of the flask api. """
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(tests.HERE, 'tickets'))
tests.create_tokens(self.session)
tests.create_acls(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token aaabbbcccddd'}
# Invalid project
output = self.app.post('/api/0/foo/issue/1/status', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Project not found",
"error_code": "ENOPROJECT",
}
)
# Valid token, wrong project
output = self.app.post('/api/0/test2/issue/1/status', headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit " \
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK",
}
)
# No input
output = self.app.post('/api/0/test/issue/1/status', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Issue not found",
"error_code": "ENOISSUE",
}
)
# Create normal issue
repo = pagure.lib.get_project(self.session, 'test')
msg = pagure.lib.new_issue(
session=self.session,
repo=repo,
title='Test issue #1',
content='We should work on this',
user='******',
ticketfolder=None,
private=False,
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue #1')
# Create another project
item = pagure.lib.model.Project(
user_id=2, # pingou
name='foo',
description='test project #3',
hook_token='aaabbbdddeee',
)
self.session.add(item)
self.session.commit()
# Create a token for pingou for this project
item = pagure.lib.model.Token(
id='pingou_foo',
user_id=1,
project_id=3,
expiration=datetime.datetime.utcnow() + datetime.timedelta(
days=30)
)
self.session.add(item)
self.session.commit()
# Give `change_status_issue` to this token
item = pagure.lib.model.TokenAcl(
token_id='pingou_foo',
acl_id=4,
)
self.session.add(item)
self.session.commit()
repo = pagure.lib.get_project(self.session, 'foo')
# Create private issue
msg = pagure.lib.new_issue(
session=self.session,
repo=repo,
title='Test issue',
content='We should work on this',
user='******',
ticketfolder=None,
private=True,
)
self.session.commit()
self.assertEqual(msg.title, 'Test issue')
# Check status before
repo = pagure.lib.get_project(self.session, 'test')
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(issue.status, 'Open')
data = {
'title': 'test issue',
}
# Incomplete request
output = self.app.post(
'/api/0/test/issue/1/status', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
}
)
# No change
repo = pagure.lib.get_project(self.session, 'test')
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(issue.status, 'Open')
data = {
'status': 'Open',
}
# Valid request but no change
output = self.app.post(
'/api/0/test/issue/1/status', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'No changes'}
)
# No change
repo = pagure.lib.get_project(self.session, 'test')
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(issue.status, 'Open')
data = {
'status': 'Fixed',
}
# Valid request
output = self.app.post(
'/api/0/test/issue/1/status', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Successfully edited issue #1'}
)
headers = {'Authorization': 'token pingou_foo'}
# Un-authorized issue
output = self.app.post(
'/api/0/foo/issue/1/status', data=data, headers=headers)
self.assertEqual(output.status_code, 403)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "You are not allowed to view this issue",
"error_code": "EISSUENOTALLOWED",
}
)
def test_api_change_status_issue(self):
""" Test the api_change_status_issue method of the flask api. """
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(tests.HERE, "tickets"))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {"Authorization": "token aaabbbcccddd"}
# Invalid project
output = self.app.post("/api/0/foo/issue/1/status", headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(data, {"error": "Project not found", "error_code": "ENOPROJECT"})
# Valid token, wrong project
output = self.app.post("/api/0/test2/issue/1/status", headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit "
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK",
},
)
# No input
output = self.app.post("/api/0/test/issue/1/status", headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(data, {"error": "Issue not found", "error_code": "ENOISSUE"})
# Create normal issue
repo = pagure.lib.get_project(self.session, "test")
msg = pagure.lib.new_issue(
session=self.session,
repo=repo,
title="Test issue #1",
content="We should work on this",
user="******",
ticketfolder=None,
private=False,
)
self.session.commit()
self.assertEqual(msg.title, "Test issue #1")
# Create another project
item = pagure.lib.model.Project(
user_id=2, name="foo", description="test project #3", hook_token="aaabbbdddeee" # pingou
)
self.session.add(item)
self.session.commit()
# Create a token for pingou for this project
item = pagure.lib.model.Token(
id="pingou_foo",
user_id=1,
project_id=3,
expiration=datetime.datetime.utcnow() + datetime.timedelta(days=30),
)
self.session.add(item)
self.session.commit()
# Give `change_status_issue` to this token
item = pagure.lib.model.TokenAcl(token_id="pingou_foo", acl_id=6)
self.session.add(item)
self.session.commit()
repo = pagure.lib.get_project(self.session, "foo")
# Create private issue
msg = pagure.lib.new_issue(
session=self.session,
repo=repo,
title="Test issue",
content="We should work on this",
user="******",
ticketfolder=None,
private=True,
)
self.session.commit()
self.assertEqual(msg.title, "Test issue")
# Check status before
repo = pagure.lib.get_project(self.session, "test")
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(issue.status, "Open")
data = {"title": "test issue"}
# Incomplete request
output = self.app.post("/api/0/test/issue/1/status", data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(data, {"error": "Invalid or incomplete input submited", "error_code": "EINVALIDREQ"})
# No change
repo = pagure.lib.get_project(self.session, "test")
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(issue.status, "Open")
data = {"status": "Open"}
# Valid request but no change
output = self.app.post("/api/0/test/issue/1/status", data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(data, {"message": "No changes"})
# No change
repo = pagure.lib.get_project(self.session, "test")
issue = pagure.lib.search_issues(self.session, repo, issueid=1)
self.assertEqual(issue.status, "Open")
data = {"status": "Fixed"}
# Valid request
output = self.app.post("/api/0/test/issue/1/status", data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(data, {"message": "Successfully edited issue #1"})
headers = {"Authorization": "token pingou_foo"}
# Un-authorized issue
output = self.app.post("/api/0/foo/issue/1/status", data=data, headers=headers)
self.assertEqual(output.status_code, 403)
data = json.loads(output.data)
self.assertDictEqual(
data, {"error": "You are not allowed to view this issue", "error_code": "EISSUENOTALLOWED"}
)
def test_api_fork_project(self, p_gga):
""" Test the api_fork_project method of the flask api. """
p_gga.return_value = True
tests.create_projects(self.session)
for folder in ['docs', 'tickets', 'requests', 'repos']:
tests.create_projects_git(
os.path.join(self.path, folder), bare=True)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token foo_token'}
# Invalid token
output = self.app.post('/api/0/fork', headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertEqual(pagure.api.APIERROR.EINVALIDTOK.name,
data['error_code'])
self.assertEqual(pagure.api.APIERROR.EINVALIDTOK.value, data['error'])
headers = {'Authorization': 'token aaabbbcccddd'}
# No input
output = self.app.post('/api/0/fork', headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
"errors": {"repo": ["This field is required."]}
}
)
data = {
'name': 'test',
}
# Incomplete request
output = self.app.post(
'/api/0/fork', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
"errors": {"repo": ["This field is required."]}
}
)
data = {
'repo': 'test',
}
# Valid request
output = self.app.post(
'/api/0/fork/', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"message": "Repo \"test\" cloned to \"pingou/test\""
}
)
data = {
'repo': 'test',
}
# project already forked
output = self.app.post(
'/api/0/fork/', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Repo \"forks/pingou/test\" already exists",
"error_code": "ENOCODE"
}
)
data = {
'repo': 'test',
'username': '******',
}
# Fork already exists
output = self.app.post(
'/api/0/fork/', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Repo \"forks/pingou/test\" already exists",
"error_code": "ENOCODE"
}
)
data = {
'repo': 'test',
'namespace': 'pingou',
}
# Repo does not exists
output = self.app.post(
'/api/0/fork/', data=data, headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Project not found",
"error_code": "ENOPROJECT"
}
)
def test_api_pull_request_add_flag(self, mockemail):
""" Test the api_pull_request_add_flag method of the flask api. """
mockemail.return_value = True
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token aaabbbcccddd'}
# Invalid project
output = self.app.post(
'/api/0/foo/pull-request/1/flag', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Project not found",
"error_code": "ENOPROJECT",
}
)
# Valid token, wrong project
output = self.app.post(
'/api/0/test2/pull-request/1/flag', headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit " \
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK",
}
)
# No input
output = self.app.post(
'/api/0/test/pull-request/1/flag', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Pull-Request not found",
"error_code": "ENOREQ",
}
)
# Create a pull-request
repo = pagure.lib.get_project(self.session, 'test')
forked_repo = pagure.lib.get_project(self.session, 'test')
req = pagure.lib.new_pull_request(
session=self.session,
repo_from=forked_repo,
branch_from='master',
repo_to=repo,
branch_to='master',
title='test pull-request',
user='******',
requestfolder=None,
)
self.session.commit()
self.assertEqual(req.id, 1)
self.assertEqual(req.title, 'test pull-request')
# Check comments before
request = pagure.lib.search_pull_requests(
self.session, project_id=1, requestid=1)
self.assertEqual(len(request.flags), 0)
data = {
'username': '******',
'percent': 100,
'url': 'http://jenkins.cloud.fedoraproject.org/',
'uid': 'jenkins_build_pagure_100+seed',
}
# Incomplete request
output = self.app.post(
'/api/0/test/pull-request/1/flag', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
}
)
# No change
request = pagure.lib.search_pull_requests(
self.session, project_id=1, requestid=1)
self.assertEqual(len(request.flags), 0)
data = {
'username': '******',
'percent': 0,
'comment': 'Tests failed',
'url': 'http://jenkins.cloud.fedoraproject.org/',
'uid': 'jenkins_build_pagure_100+seed',
}
# Valid request
output = self.app.post(
'/api/0/test/pull-request/1/flag', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Flag added'}
)
# One flag added
request = pagure.lib.search_pull_requests(
self.session, project_id=1, requestid=1)
self.assertEqual(len(request.flags), 1)
self.assertEqual(request.flags[0].comment, 'Tests failed')
self.assertEqual(request.flags[0].percent, 0)
# Update flag
data = {
'username': '******',
'percent': 100,
'comment': 'Tests passed',
'url': 'http://jenkins.cloud.fedoraproject.org/',
'uid': 'jenkins_build_pagure_100+seed',
}
output = self.app.post(
'/api/0/test/pull-request/1/flag', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Flag updated'}
)
# One flag added
request = pagure.lib.search_pull_requests(
self.session, project_id=1, requestid=1)
self.assertEqual(len(request.flags), 1)
self.assertEqual(request.flags[0].comment, 'Tests passed')
self.assertEqual(request.flags[0].percent, 100)
def test_api_pull_request_add_comment(self, mockemail):
""" Test the api_pull_request_add_comment method of the flask api. """
mockemail.return_value = True
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token aaabbbcccddd'}
# Invalid project
output = self.app.post(
'/api/0/foo/pull-request/1/comment', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Project not found",
"error_code": "ENOPROJECT",
}
)
# Valid token, wrong project
output = self.app.post(
'/api/0/test2/pull-request/1/comment', headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit " \
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK",
}
)
# No input
output = self.app.post(
'/api/0/test/pull-request/1/comment', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Pull-Request not found",
"error_code": "ENOREQ",
}
)
# Create a pull-request
repo = pagure.lib.get_project(self.session, 'test')
forked_repo = pagure.lib.get_project(self.session, 'test')
req = pagure.lib.new_pull_request(
session=self.session,
repo_from=forked_repo,
branch_from='master',
repo_to=repo,
branch_to='master',
title='test pull-request',
user='******',
requestfolder=None,
)
self.session.commit()
self.assertEqual(req.id, 1)
self.assertEqual(req.title, 'test pull-request')
# Check comments before
request = pagure.lib.search_pull_requests(
self.session, project_id=1, requestid=1)
self.assertEqual(len(request.comments), 0)
data = {
'title': 'test issue',
}
# Incomplete request
output = self.app.post(
'/api/0/test/pull-request/1/comment', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
}
)
# No change
request = pagure.lib.search_pull_requests(
self.session, project_id=1, requestid=1)
self.assertEqual(len(request.comments), 0)
data = {
'comment': 'This is a very interesting question',
}
# Valid request
output = self.app.post(
'/api/0/test/pull-request/1/comment', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Comment added'}
)
# One comment added
request = pagure.lib.search_pull_requests(
self.session, project_id=1, requestid=1)
self.assertEqual(len(request.comments), 1)
def test_api_new_project(self, p_gga):
""" Test the api_new_project method of the flask api. """
p_gga.return_value = True
tests.create_projects(self.session)
tests.create_projects_git(os.path.join(tests.HERE, 'tickets'))
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token foo_token'}
# Invalid token
output = self.app.post('/api/0/new', headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit " \
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK"
}
)
headers = {'Authorization': 'token aaabbbcccddd'}
# No input
output = self.app.post('/api/0/new', headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
}
)
data = {
'name': 'test',
}
# Incomplete request
output = self.app.post(
'/api/0/new', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or incomplete input submited",
"error_code": "EINVALIDREQ",
}
)
data = {
'name': 'test',
'description': 'Just a small test project',
}
# Valid request but repo already exists
output = self.app.post(
'/api/0/new/', data=data, headers=headers)
self.assertEqual(output.status_code, 400)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "The tickets repo \"test.git\" already exists",
"error_code": "ENOCODE"
}
)
data = {
'name': 'test_42',
'description': 'Just another small test project',
}
# Valid request
output = self.app.post(
'/api/0/new/', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Project "test_42" created'}
)
def test_api_pull_request_close(self, send_email):
""" Test the api_pull_request_close method of the flask api. """
send_email.return_value = True
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create the pull-request to close
repo = pagure.lib.get_project(self.session, 'test')
forked_repo = pagure.lib.get_project(self.session, 'test')
req = pagure.lib.new_pull_request(
session=self.session,
repo_from=forked_repo,
branch_from='master',
repo_to=repo,
branch_to='master',
title='test pull-request',
user='******',
requestfolder=None,
)
self.session.commit()
self.assertEqual(req.id, 1)
self.assertEqual(req.title, 'test pull-request')
headers = {'Authorization': 'token aaabbbcccddd'}
# Invalid project
output = self.app.post(
'/api/0/foo/pull-request/1/close', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Project not found",
"error_code": "ENOPROJECT",
}
)
# Valid token, wrong project
output = self.app.post(
'/api/0/test2/pull-request/1/close', headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertEqual(pagure.api.APIERROR.EINVALIDTOK.name,
data['error_code'])
self.assertEqual(pagure.api.APIERROR.EINVALIDTOK.value, data['error'])
# Invalid PR
output = self.app.post(
'/api/0/test/pull-request/2/close', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'error': 'Pull-Request not found', 'error_code': "ENOREQ"}
)
# Create a token for foo for this project
item = pagure.lib.model.Token(
id='foobar_token',
user_id=2,
project_id=1,
expiration=datetime.datetime.utcnow() + datetime.timedelta(
days=30)
)
self.session.add(item)
self.session.commit()
# Allow the token to close PR
acls = pagure.lib.get_acls(self.session)
acl = None
for acl in acls:
if acl.name == 'pull_request_close':
break
item = pagure.lib.model.TokenAcl(
token_id='foobar_token',
acl_id=acl.id,
)
self.session.add(item)
self.session.commit()
headers = {'Authorization': 'token foobar_token'}
# User not admin
output = self.app.post(
'/api/0/test/pull-request/1/close', headers=headers)
self.assertEqual(output.status_code, 403)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
'error': 'You are not allowed to merge/close pull-request '
'for this project',
'error_code': "ENOPRCLOSE",
}
)
headers = {'Authorization': 'token aaabbbcccddd'}
# Close PR
output = self.app.post(
'/api/0/test/pull-request/1/close', headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{"message": "Pull-request closed!"}
)
def test_api_pull_request_merge(self, mpr, send_email):
""" Test the api_pull_request_merge method of the flask api. """
mpr.return_value = 'Changes merged!'
send_email.return_value = True
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
# Create the pull-request to close
repo = pagure.lib.get_project(self.session, 'test')
forked_repo = pagure.lib.get_project(self.session, 'test')
req = pagure.lib.new_pull_request(
session=self.session,
repo_from=forked_repo,
branch_from='master',
repo_to=repo,
branch_to='master',
title='test pull-request',
user='******',
requestfolder=None,
)
self.session.commit()
self.assertEqual(req.id, 1)
self.assertEqual(req.title, 'test pull-request')
headers = {'Authorization': 'token aaabbbcccddd'}
# Invalid project
output = self.app.post(
'/api/0/foo/pull-request/1/merge', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Project not found",
"error_code": "ENOPROJECT",
}
)
# Valid token, wrong project
output = self.app.post(
'/api/0/test2/pull-request/1/merge', headers=headers)
self.assertEqual(output.status_code, 401)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
"error": "Invalid or expired token. Please visit " \
"https://pagure.org/ to get or renew your API token.",
"error_code": "EINVALIDTOK",
}
)
# Invalid PR
output = self.app.post(
'/api/0/test/pull-request/2/merge', headers=headers)
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'error': 'Pull-Request not found', 'error_code': "ENOREQ"}
)
# Create a token for foo for this project
item = pagure.lib.model.Token(
id='foobar_token',
user_id=2,
project_id=1,
expiration=datetime.datetime.utcnow() + datetime.timedelta(
days=30)
)
self.session.add(item)
self.session.commit()
# Allow the token to merge PR
item = pagure.lib.model.TokenAcl(
token_id='foobar_token',
acl_id=10,
)
self.session.add(item)
self.session.commit()
headers = {'Authorization': 'token foobar_token'}
# User not admin
output = self.app.post(
'/api/0/test/pull-request/1/merge', headers=headers)
self.assertEqual(output.status_code, 403)
data = json.loads(output.data)
self.assertDictEqual(
data,
{
'error': 'You are not allowed to merge/close pull-request '
'for this project',
'error_code': "ENOPRCLOSE",
}
)
headers = {'Authorization': 'token aaabbbcccddd'}
# Merge PR
output = self.app.post(
'/api/0/test/pull-request/1/merge', headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{"message": "Changes merged!"}
)
def test_api_view_user_activity_stats(self, mockemail):
""" Test the api_view_user_activity_stats method of the flask user
api. """
mockemail.return_value = True
tests.create_projects(self.session)
tests.create_tokens(self.session)
tests.create_tokens_acl(self.session)
headers = {'Authorization': 'token aaabbbcccddd'}
# Create a pull-request
repo = pagure.lib.get_project(self.session, 'test')
forked_repo = pagure.lib.get_project(self.session, 'test')
req = pagure.lib.new_pull_request(
session=self.session,
repo_from=forked_repo,
branch_from='master',
repo_to=repo,
branch_to='master',
title='test pull-request',
user='******',
requestfolder=None,
)
self.session.commit()
self.assertEqual(req.id, 1)
self.assertEqual(req.title, 'test pull-request')
# Check comments before
request = pagure.lib.search_pull_requests(
self.session, project_id=1, requestid=1)
self.assertEqual(len(request.comments), 0)
data = {
'comment': 'This is a very interesting question',
}
# Valid request
output = self.app.post(
'/api/0/test/pull-request/1/comment', data=data, headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{'message': 'Comment added'}
)
# One comment added
request = pagure.lib.search_pull_requests(
self.session, project_id=1, requestid=1)
self.assertEqual(len(request.comments), 1)
# Close PR
output = self.app.post(
'/api/0/test/pull-request/1/close', headers=headers)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertDictEqual(
data,
{"message": "Pull-request closed!"}
)
# PR closed
request = pagure.lib.search_pull_requests(
self.session, project_id=1, requestid=1)
self.assertEqual(request.status, 'Closed')
# Finally retrieve the user's logs
output = self.app.get('/api/0/user/pingou/activity/stats')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
date = datetime.datetime.utcnow().date().strftime('%Y-%m-%d')
# There seems to be a difference in the JSON generated between
# flask-0.10.1 (F23) and 0.11.1 (jenkins)
self.assertTrue(
data == {date: 4}
or
data == [[date, 4]]
)
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()
