# -*- coding: utf-8 -*-
"""
(c) 2017-2018 - Copyright Red Hat Inc
Authors:
Pierre-Yves Chibon <pingou@pingoured.fr>
"""
from __future__ import unicode_literals, absolute_import
import datetime # noqa
import os # noqa
import platform # noqa
import shutil # noqa
import subprocess # noqa
import sys # noqa
import unittest # noqa
import pygit2
import munch # noqa
from mock import patch, MagicMock # noqa
from six import StringIO # noqa
sys.path.insert(
0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
)
import pagure.config # noqa
import pagure.exceptions # noqa: E402
import pagure.cli.admin # noqa
import pagure.lib.model # noqa
import tests # noqa
class PagureAdminAdminTokenEmptytests(tests.Modeltests):
""" Tests for pagure-admin admin-token when there is nothing in the DB
"""
populate_db = False
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureAdminAdminTokenEmptytests, self).setUp()
pagure.cli.admin.session = self.session
def test_do_create_admin_token_no_user(self):
""" Test the do_create_admin_token function of pagure-admin without
user.
"""
args = munch.Munch({"user": "pingou"})
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_create_admin_token(args)
self.assertEqual(cm.exception.args[0], 'No user "pingou" found')
def test_do_list_admin_token_empty(self):
""" Test the do_list_admin_token function of pagure-admin when there
are not tokens in the db.
"""
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": False,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertEqual(output, "No admin tokens found\n")
class PagureAdminAdminRefreshGitolitetests(tests.Modeltests):
""" Tests for pagure-admin refresh-gitolite """
populate_db = False
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureAdminAdminRefreshGitolitetests, self).setUp()
pagure.cli.admin.session = self.session
# Create the user pingou
item = pagure.lib.model.User(
user="pingou",
fullname="PY C",
password="foo",
default_email="bar@pingou.com",
)
self.session.add(item)
item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")
self.session.add(item)
self.session.commit()
# Create a couple of projects
tests.create_projects(self.session)
# Add a group
msg = pagure.lib.query.add_group(
self.session,
group_name="foo",
display_name="foo group",
description=None,
group_type="bar",
user="pingou",
is_admin=False,
blacklist=[],
)
self.session.commit()
self.assertEqual(msg, "User `pingou` added to the group `foo`.")
# Make the imported pagure use the correct db session
pagure.cli.admin.session = self.session
@patch("pagure.cli.admin._ask_confirmation")
@patch("pagure.lib.git_auth.get_git_auth_helper")
def test_do_refresh_gitolite_no_args(self, get_helper, conf):
""" Test the do_generate_acl function with no special args. """
conf.return_value = True
helper = MagicMock()
get_helper.return_value = helper
args = munch.Munch(
{"group": None, "project": None, "all_": False, "user": None}
)
pagure.cli.admin.do_generate_acl(args)
get_helper.assert_called_with()
args = helper.generate_acls.call_args
self.assertIsNone(args[1].get("group"))
self.assertIsNone(args[1].get("project"))
@patch("pagure.cli.admin._ask_confirmation")
@patch("pagure.lib.git_auth.get_git_auth_helper")
def test_do_refresh_gitolite_all_project(self, get_helper, conf):
""" Test the do_generate_acl function for all projects. """
conf.return_value = True
helper = MagicMock()
get_helper.return_value = helper
args = munch.Munch(
{"group": None, "project": None, "all_": True, "user": None}
)
pagure.cli.admin.do_generate_acl(args)
get_helper.assert_called_with()
args = helper.generate_acls.call_args
self.assertIsNone(args[1].get("group"))
self.assertEqual(args[1].get("project"), -1)
@patch("pagure.cli.admin._ask_confirmation")
@patch("pagure.lib.git_auth.get_git_auth_helper")
def test_do_refresh_gitolite_one_project(self, get_helper, conf):
""" Test the do_generate_acl function for a certain project. """
conf.return_value = True
helper = MagicMock()
get_helper.return_value = helper
args = munch.Munch(
{"group": None, "project": "test", "all_": False, "user": None}
)
pagure.cli.admin.do_generate_acl(args)
get_helper.assert_called_with()
args = helper.generate_acls.call_args
self.assertIsNone(args[1].get("group"))
self.assertEqual(args[1].get("project").fullname, "test")
@patch("pagure.cli.admin._ask_confirmation")
@patch("pagure.lib.git_auth.get_git_auth_helper")
def test_do_refresh_gitolite_one_project_and_all(self, get_helper, conf):
""" Test the do_generate_acl function for a certain project and all.
"""
conf.return_value = True
helper = MagicMock()
get_helper.return_value = helper
args = munch.Munch(
{"group": None, "project": "test", "all_": True, "user": None}
)
pagure.cli.admin.do_generate_acl(args)
get_helper.assert_called_with()
args = helper.generate_acls.call_args
self.assertIsNone(args[1].get("group"))
self.assertEqual(args[1].get("project"), -1)
@patch("pagure.cli.admin._ask_confirmation")
@patch("pagure.lib.git_auth.get_git_auth_helper")
def test_do_refresh_gitolite_one_group(self, get_helper, conf):
""" Test the do_generate_acl function for a certain group. """
conf.return_value = True
helper = MagicMock()
get_helper.return_value = helper
args = munch.Munch(
{"group": "foo", "project": None, "all_": False, "user": None}
)
pagure.cli.admin.do_generate_acl(args)
get_helper.assert_called_with()
args = helper.generate_acls.call_args
self.assertEqual(args[1].get("group").group_name, "foo")
self.assertIsNone(args[1].get("project"))
class PagureAdminAdminTokentests(tests.Modeltests):
""" Tests for pagure-admin admin-token """
populate_db = False
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureAdminAdminTokentests, self).setUp()
pagure.cli.admin.session = self.session
# Create the user pingou
item = pagure.lib.model.User(
user="pingou",
fullname="PY C",
password="foo",
default_email="bar@pingou.com",
)
self.session.add(item)
item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")
self.session.add(item)
self.session.commit()
# Make the imported pagure use the correct db session
pagure.cli.admin.session = self.session
@patch("pagure.cli.admin._get_input")
@patch("pagure.cli.admin._ask_confirmation")
def test_do_create_admin_token(self, conf, rinp):
""" Test the do_create_admin_token function of pagure-admin. """
conf.return_value = True
rinp.return_value = "1,2,3"
args = munch.Munch({"user": "pingou"})
pagure.cli.admin.do_create_admin_token(args)
# Check the outcome
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": False,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertNotEqual(output, 'No user "pingou" found\n')
self.assertEqual(len(output.split("\n")), 2)
self.assertIn(" -- pingou -- ", output)
@patch("pagure.cli.admin._get_input")
@patch("pagure.cli.admin._ask_confirmation")
def test_do_list_admin_token(self, conf, rinp):
""" Test the do_list_admin_token function of pagure-admin. """
# Create an admin token to use
conf.return_value = True
rinp.return_value = "1,2,3"
args = munch.Munch({"user": "pingou"})
pagure.cli.admin.do_create_admin_token(args)
# Retrieve all tokens
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": False,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertNotEqual(output, 'No user "pingou" found\n')
self.assertEqual(len(output.split("\n")), 2)
self.assertIn(" -- pingou -- ", output)
# Retrieve pfrields's tokens
list_args = munch.Munch(
{
"user": "pfrields",
"token": None,
"active": False,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertEqual(output, "No admin tokens found\n")
def test_do_list_admin_token_non_admin_acls(self):
""" Test the do_list_admin_token function of pagure-admin for a token
without any admin ACL. """
pagure.lib.query.add_token_to_user(
self.session,
project=None,
acls=["issue_assign", "pull_request_subscribe"],
username="pingou",
)
# Retrieve all admin tokens
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": False,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertEqual(output, "No admin tokens found\n")
# Retrieve all tokens
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": False,
"expired": False,
"all": True,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertNotEqual(output, 'No user "pingou" found\n')
self.assertEqual(len(output.split("\n")), 2)
self.assertIn(" -- pingou -- ", output)
@patch("pagure.cli.admin._get_input")
@patch("pagure.cli.admin._ask_confirmation")
def test_do_info_admin_token(self, conf, rinp):
""" Test the do_info_admin_token function of pagure-admin. """
# Create an admin token to use
conf.return_value = True
rinp.return_value = "2,4,5"
args = munch.Munch({"user": "pingou"})
pagure.cli.admin.do_create_admin_token(args)
# Retrieve the token
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": False,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertNotEqual(output, 'No user "pingou" found\n')
self.assertEqual(len(output.split("\n")), 2)
self.assertIn(" -- pingou -- ", output)
token = output.split(" ", 1)[0]
args = munch.Munch({"token": token})
with tests.capture_output() as output:
pagure.cli.admin.do_info_admin_token(args)
output = output.getvalue()
self.assertIn(" -- pingou -- ", output.split("\n", 1)[0])
self.assertEqual(
output.split("\n", 1)[1],
"""ACLs:
- issue_create
- pull_request_comment
- pull_request_flag
""",
)
def test_do_info_admin_token_non_admin_acl(self):
""" Test the do_info_admin_token function of pagure-admin for a
token not having any admin ACL. """
pagure.lib.query.add_token_to_user(
self.session,
project=None,
acls=["issue_assign", "pull_request_subscribe"],
username="pingou",
)
# Retrieve the token
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": False,
"expired": False,
"all": True,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertNotEqual(output, 'No user "pingou" found\n')
self.assertEqual(len(output.split("\n")), 2)
self.assertIn(" -- pingou -- ", output)
token = output.split(" ", 1)[0]
args = munch.Munch({"token": token})
with tests.capture_output() as output:
pagure.cli.admin.do_info_admin_token(args)
output = output.getvalue()
self.assertIn(" -- pingou -- ", output.split("\n", 1)[0])
self.assertEqual(
output.split("\n", 1)[1],
"""ACLs:
- issue_assign
- pull_request_subscribe
""",
)
@patch("pagure.cli.admin._get_input")
@patch("pagure.cli.admin._ask_confirmation")
def test_do_expire_admin_token(self, conf, rinp):
""" Test the do_expire_admin_token function of pagure-admin. """
if "BUILD_ID" in os.environ:
raise unittest.case.SkipTest("Skipping on jenkins/el7")
# Create an admin token to use
conf.return_value = True
rinp.return_value = "1,2,3"
args = munch.Munch({"user": "pingou"})
pagure.cli.admin.do_create_admin_token(args)
# Retrieve the token
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": False,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertNotEqual(output, 'No user "pingou" found\n')
self.assertEqual(len(output.split("\n")), 2)
self.assertIn(" -- pingou -- ", output)
token = output.split(" ", 1)[0]
# Before
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": True,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertNotEqual(output, "No admin tokens found\n")
self.assertEqual(len(output.split("\n")), 2)
self.assertIn(" -- pingou -- ", output)
# Expire the token
args = munch.Munch({"token": token})
pagure.cli.admin.do_expire_admin_token(args)
# After
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": True,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertEqual(output, "No admin tokens found\n")
@patch("pagure.cli.admin._get_input")
@patch("pagure.cli.admin._ask_confirmation")
def test_do_update_admin_token_invalid_date(self, conf, rinp):
""" Test the do_update_admin_token function of pagure-admin with
an invalid date. """
if "BUILD_ID" in os.environ:
raise unittest.case.SkipTest("Skipping on jenkins/el7")
# Create an admin token to use
conf.return_value = True
rinp.return_value = "1,2,3"
args = munch.Munch({"user": "pingou"})
pagure.cli.admin.do_create_admin_token(args)
# Retrieve the token
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": False,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertNotEqual(output, 'No user "pingou" found\n')
self.assertEqual(len(output.split("\n")), 2)
self.assertIn(" -- pingou -- ", output)
token = output.split(" ", 1)[0]
current_expiration = output.split(" ", 1)[1]
# Set the expiration date to the token
args = munch.Munch({"token": token, "date": "aa-bb-cc"})
self.assertRaises(
pagure.exceptions.PagureException,
pagure.cli.admin.do_update_admin_token,
args,
)
@patch("pagure.cli.admin._get_input")
@patch("pagure.cli.admin._ask_confirmation")
def test_do_update_admin_token_invalid_date2(self, conf, rinp):
""" Test the do_update_admin_token function of pagure-admin with
an invalid date. """
if "BUILD_ID" in os.environ:
raise unittest.case.SkipTest("Skipping on jenkins/el7")
# Create an admin token to use
conf.return_value = True
rinp.return_value = "1,2,3"
args = munch.Munch({"user": "pingou"})
pagure.cli.admin.do_create_admin_token(args)
# Retrieve the token
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": False,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertNotEqual(output, 'No user "pingou" found\n')
self.assertEqual(len(output.split("\n")), 2)
self.assertIn(" -- pingou -- ", output)
token = output.split(" ", 1)[0]
current_expiration = output.split(" ", 1)[1]
# Set the expiration date to the token
args = munch.Munch({"token": token, "date": "2017-18-01"})
self.assertRaises(
pagure.exceptions.PagureException,
pagure.cli.admin.do_update_admin_token,
args,
)
@patch("pagure.cli.admin._get_input")
@patch("pagure.cli.admin._ask_confirmation")
def test_do_update_admin_token_invalid_date3(self, conf, rinp):
""" Test the do_update_admin_token function of pagure-admin with
an invalid date (is today). """
if "BUILD_ID" in os.environ:
raise unittest.case.SkipTest("Skipping on jenkins/el7")
# Create an admin token to use
conf.return_value = True
rinp.return_value = "1,2,3"
args = munch.Munch({"user": "pingou"})
pagure.cli.admin.do_create_admin_token(args)
# Retrieve the token
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": False,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertNotEqual(output, 'No user "pingou" found\n')
self.assertEqual(len(output.split("\n")), 2)
self.assertIn(" -- pingou -- ", output)
token = output.split(" ", 1)[0]
current_expiration = output.split(" ", 1)[1]
# Set the expiration date to the token
args = munch.Munch(
{"token": token, "date": datetime.datetime.utcnow().date()}
)
self.assertRaises(
pagure.exceptions.PagureException,
pagure.cli.admin.do_update_admin_token,
args,
)
@patch("pagure.cli.admin._get_input")
@patch("pagure.cli.admin._ask_confirmation")
def test_do_update_admin_token(self, conf, rinp):
""" Test the do_update_admin_token function of pagure-admin. """
if "BUILD_ID" in os.environ:
raise unittest.case.SkipTest("Skipping on jenkins/el7")
# Create an admin token to use
conf.return_value = True
rinp.return_value = "1,2,3"
args = munch.Munch({"user": "pingou"})
pagure.cli.admin.do_create_admin_token(args)
# Retrieve the token
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": False,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertNotEqual(output, 'No user "pingou" found\n')
self.assertEqual(len(output.split("\n")), 2)
self.assertIn(" -- pingou -- ", output)
token = output.split(" ", 1)[0]
current_expiration = output.strip().split(" -- ", 2)[-1]
# Before
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": True,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertNotEqual(output, "No admin tokens found\n")
self.assertEqual(len(output.split("\n")), 2)
self.assertIn(" -- pingou -- ", output)
deadline = datetime.datetime.utcnow().date() + datetime.timedelta(
days=3
)
# Set the expiration date to the token
args = munch.Munch(
{"token": token, "date": deadline.strftime("%Y-%m-%d")}
)
pagure.cli.admin.do_update_admin_token(args)
# After
list_args = munch.Munch(
{
"user": None,
"token": None,
"active": True,
"expired": False,
"all": False,
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_list_admin_token(list_args)
output = output.getvalue()
self.assertEqual(output.split(" ", 1)[0], token)
self.assertNotEqual(
output.strip().split(" -- ", 2)[-1], current_expiration
)
class PagureAdminGetWatchTests(tests.Modeltests):
""" Tests for pagure-admin get-watch """
populate_db = False
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureAdminGetWatchTests, self).setUp()
pagure.cli.admin.session = self.session
# Create the user pingou
item = pagure.lib.model.User(
user="pingou",
fullname="PY C",
password="foo",
default_email="bar@pingou.com",
)
self.session.add(item)
item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")
self.session.add(item)
# Create the user foo
item = pagure.lib.model.User(
user="foo",
fullname="foo B.",
password="foob",
default_email="foo@pingou.com",
)
self.session.add(item)
# Create two projects for the user pingou
item = pagure.lib.model.Project(
user_id=1, # pingou
name="test",
description="namespaced test project",
hook_token="aaabbbeee",
namespace="somenamespace",
)
self.session.add(item)
item = pagure.lib.model.Project(
user_id=1, # pingou
name="test",
description="Test project",
hook_token="aaabbbccc",
namespace=None,
)
self.session.add(item)
self.session.commit()
# Make the imported pagure use the correct db session
pagure.cli.admin.session = self.session
def test_get_watch_get_project_unknown_project(self):
""" Test the get-watch function of pagure-admin with an unknown
project.
"""
args = munch.Munch({"project": "foobar", "user": "pingou"})
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_get_watch_status(args)
self.assertEqual(cm.exception.args[0], "No project found with: foobar")
def test_get_watch_get_project_invalid_project(self):
""" Test the get-watch function of pagure-admin with an invalid
project.
"""
args = munch.Munch({"project": "fo/o/bar", "user": "pingou"})
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_get_watch_status(args)
self.assertEqual(
cm.exception.args[0],
'Invalid project name, has more than one "/": fo/o/bar',
)
def test_get_watch_get_project_invalid_user(self):
""" Test the get-watch function of pagure-admin on a invalid user.
"""
args = munch.Munch({"project": "test", "user": "beebop"})
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_get_watch_status(args)
self.assertEqual(cm.exception.args[0], 'No user "beebop" found')
def test_get_watch_get_project(self):
""" Test the get-watch function of pagure-admin on a regular project.
"""
args = munch.Munch({"project": "test", "user": "pingou"})
with tests.capture_output() as output:
pagure.cli.admin.do_get_watch_status(args)
output = output.getvalue()
self.assertEqual(
"On test user: pingou is watching the following items: "
"issues, pull-requests\n",
output,
)
def test_get_watch_get_project_not_watching(self):
""" Test the get-watch function of pagure-admin on a regular project.
"""
args = munch.Munch({"project": "test", "user": "foo"})
with tests.capture_output() as output:
pagure.cli.admin.do_get_watch_status(args)
output = output.getvalue()
self.assertEqual(
"On test user: foo is watching the following items: None\n", output
)
def test_get_watch_get_project_namespaced(self):
""" Test the get-watch function of pagure-admin on a namespaced project.
"""
args = munch.Munch({"project": "somenamespace/test", "user": "pingou"})
with tests.capture_output() as output:
pagure.cli.admin.do_get_watch_status(args)
output = output.getvalue()
self.assertEqual(
"On somenamespace/test user: pingou is watching the following "
"items: issues, pull-requests\n",
output,
)
def test_get_watch_get_project_namespaced_not_watching(self):
""" Test the get-watch function of pagure-admin on a namespaced project.
"""
args = munch.Munch({"project": "somenamespace/test", "user": "foo"})
with tests.capture_output() as output:
pagure.cli.admin.do_get_watch_status(args)
output = output.getvalue()
with tests.capture_output() as _discarded:
pagure.cli.admin.do_get_watch_status(args)
self.assertEqual(
"On somenamespace/test user: foo is watching the following "
"items: None\n",
output,
)
class PagureAdminUpdateWatchTests(tests.Modeltests):
""" Tests for pagure-admin update-watch """
populate_db = False
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureAdminUpdateWatchTests, self).setUp()
pagure.cli.admin.session = self.session
# Create the user pingou
item = pagure.lib.model.User(
user="pingou",
fullname="PY C",
password="foo",
default_email="bar@pingou.com",
)
self.session.add(item)
item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")
self.session.add(item)
# Create the user foo
item = pagure.lib.model.User(
user="foo",
fullname="foo B.",
password="foob",
default_email="foo@pingou.com",
)
self.session.add(item)
# Create two projects for the user pingou
item = pagure.lib.model.Project(
user_id=1, # pingou
name="test",
description="namespaced test project",
hook_token="aaabbbeee",
namespace="somenamespace",
)
self.session.add(item)
item = pagure.lib.model.Project(
user_id=1, # pingou
name="test",
description="Test project",
hook_token="aaabbbccc",
namespace=None,
)
self.session.add(item)
self.session.commit()
# Make the imported pagure use the correct db session
pagure.cli.admin.session = self.session
def test_get_watch_update_project_unknown_project(self):
""" Test the update-watch function of pagure-admin on an unknown
project.
"""
args = munch.Munch(
{"project": "foob", "user": "pingou", "status": "1"}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_update_watch_status(args)
self.assertEqual(cm.exception.args[0], "No project found with: foob")
def test_get_watch_update_project_invalid_project(self):
""" Test the update-watch function of pagure-admin on an invalid
project.
"""
args = munch.Munch(
{"project": "fo/o/b", "user": "pingou", "status": "1"}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_update_watch_status(args)
self.assertEqual(
cm.exception.args[0],
'Invalid project name, has more than one "/": fo/o/b',
)
def test_get_watch_update_project_invalid_user(self):
""" Test the update-watch function of pagure-admin on an invalid user.
"""
args = munch.Munch({"project": "test", "user": "foob", "status": "1"})
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_update_watch_status(args)
self.assertEqual(cm.exception.args[0], 'No user "foob" found')
def test_get_watch_update_project_invalid_status(self):
""" Test the update-watch function of pagure-admin with an invalid
status.
"""
args = munch.Munch(
{"project": "test", "user": "pingou", "status": "10"}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_update_watch_status(args)
self.assertEqual(
cm.exception.args[0],
"Invalid status provided: 10 not in -1, 0, 1, 2, 3",
)
def test_get_watch_update_project_no_effect(self):
""" Test the update-watch function of pagure-admin with a regular
project - nothing changed.
"""
args = munch.Munch({"project": "test", "user": "pingou"})
with tests.capture_output() as output:
pagure.cli.admin.do_get_watch_status(args)
output = output.getvalue()
self.assertEqual(
"On test user: pingou is watching the following items: "
"issues, pull-requests\n",
output,
)
args = munch.Munch(
{"project": "test", "user": "pingou", "status": "1"}
)
with tests.capture_output() as output:
pagure.cli.admin.do_update_watch_status(args)
output = output.getvalue()
self.assertEqual(
"Updating watch status of pingou to 1 (watch issues and PRs) "
"on test\n",
output,
)
args = munch.Munch({"project": "test", "user": "pingou"})
with tests.capture_output() as output:
pagure.cli.admin.do_get_watch_status(args)
output = output.getvalue()
self.assertEqual(
"On test user: pingou is watching the following items: "
"issues, pull-requests\n",
output,
)
class PagureAdminReadOnlyTests(tests.Modeltests):
""" Tests for pagure-admin read-only """
populate_db = False
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureAdminReadOnlyTests, self).setUp()
pagure.cli.admin.session = self.session
# Create the user pingou
item = pagure.lib.model.User(
user="pingou",
fullname="PY C",
password="foo",
default_email="bar@pingou.com",
)
self.session.add(item)
item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")
self.session.add(item)
# Create two projects for the user pingou
item = pagure.lib.model.Project(
user_id=1, # pingou
name="test",
description="namespaced test project",
hook_token="aaabbbeee",
namespace="somenamespace",
)
self.session.add(item)
item = pagure.lib.model.Project(
user_id=1, # pingou
name="test",
description="Test project",
hook_token="aaabbbccc",
namespace=None,
)
self.session.add(item)
self.session.commit()
# Make the imported pagure use the correct db session
pagure.cli.admin.session = self.session
def test_read_only_unknown_project(self):
""" Test the read-only function of pagure-admin on an unknown
project.
"""
args = munch.Munch({"project": "foob", "user": None, "ro": None})
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_read_only(args)
self.assertEqual(cm.exception.args[0], "No project found with: foob")
def test_read_only_invalid_project(self):
""" Test the read-only function of pagure-admin on an invalid
project.
"""
args = munch.Munch({"project": "fo/o/b", "user": None, "ro": None})
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_read_only(args)
self.assertEqual(
cm.exception.args[0],
'Invalid project name, has more than one "/": fo/o/b',
)
def test_read_only(self):
""" Test the read-only function of pagure-admin to get status of
a non-namespaced project.
"""
args = munch.Munch({"project": "test", "user": None, "ro": None})
with tests.capture_output() as output:
pagure.cli.admin.do_read_only(args)
output = output.getvalue()
self.assertEqual(
"The current read-only flag of the project test is set to True\n",
output,
)
def test_read_only_namespace(self):
""" Test the read-only function of pagure-admin to get status of
a namespaced project.
"""
args = munch.Munch(
{"project": "somenamespace/test", "user": None, "ro": None}
)
with tests.capture_output() as output:
pagure.cli.admin.do_read_only(args)
output = output.getvalue()
self.assertEqual(
"The current read-only flag of the project somenamespace/test "
"is set to True\n",
output,
)
def test_read_only_namespace_changed(self):
""" Test the read-only function of pagure-admin to set the status of
a namespaced project.
"""
# Before
args = munch.Munch(
{"project": "somenamespace/test", "user": None, "ro": None}
)
with tests.capture_output() as output:
pagure.cli.admin.do_read_only(args)
output = output.getvalue()
self.assertEqual(
"The current read-only flag of the project somenamespace/test "
"is set to True\n",
output,
)
args = munch.Munch(
{"project": "somenamespace/test", "user": None, "ro": "false"}
)
with tests.capture_output() as output:
pagure.cli.admin.do_read_only(args)
output = output.getvalue()
self.assertEqual(
"The read-only flag of the project somenamespace/test has been "
"set to False\n",
output,
)
# After
args = munch.Munch(
{"project": "somenamespace/test", "user": None, "ro": None}
)
with tests.capture_output() as output:
pagure.cli.admin.do_read_only(args)
output = output.getvalue()
self.assertEqual(
"The current read-only flag of the project somenamespace/test "
"is set to False\n",
output,
)
def test_read_only_no_change(self):
""" Test the read-only function of pagure-admin to set the status of
a namespaced project.
"""
# Before
args = munch.Munch({"project": "test", "user": None, "ro": None})
with tests.capture_output() as output:
pagure.cli.admin.do_read_only(args)
output = output.getvalue()
self.assertEqual(
"The current read-only flag of the project test "
"is set to True\n",
output,
)
args = munch.Munch({"project": "test", "user": None, "ro": "true"})
with tests.capture_output() as output:
pagure.cli.admin.do_read_only(args)
output = output.getvalue()
self.assertEqual(
"The read-only flag of the project test has been " "set to True\n",
output,
)
# After
args = munch.Munch({"project": "test", "user": None, "ro": None})
with tests.capture_output() as output:
pagure.cli.admin.do_read_only(args)
output = output.getvalue()
self.assertEqual(
"The current read-only flag of the project test "
"is set to True\n",
output,
)
class PagureNewGroupTests(tests.Modeltests):
""" Tests for pagure-admin new-group """
populate_db = False
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureNewGroupTests, self).setUp()
pagure.cli.admin.session = self.session
# Create the user pingou
item = pagure.lib.model.User(
user="pingou",
fullname="PY C",
password="foo",
default_email="bar@pingou.com",
)
self.session.add(item)
item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")
self.session.add(item)
self.session.commit()
# Make the imported pagure use the correct db session
pagure.cli.admin.session = self.session
groups = pagure.lib.query.search_groups(self.session)
self.assertEqual(len(groups), 0)
def test_missing_display_name(self):
""" Test the new-group function of pagure-admin when the display name
is missing from the args.
"""
args = munch.Munch(
{
"group_name": "foob",
"display": None,
"description": None,
"username": "pingou",
}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_new_group(args)
self.assertEqual(
cm.exception.args[0],
"A display name must be provided for the group",
)
groups = pagure.lib.query.search_groups(self.session)
self.assertEqual(len(groups), 0)
def test_missing_username(self):
""" Test the new-group function of pagure-admin when the username
is missing from the args.
"""
args = munch.Munch(
{
"group_name": "foob",
"display": "foo group",
"description": None,
"username": None,
}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_new_group(args)
self.assertEqual(
cm.exception.args[0],
"An username must be provided to associate with the group",
)
groups = pagure.lib.query.search_groups(self.session)
self.assertEqual(len(groups), 0)
def test_new_group(self):
""" Test the new-group function of pagure-admin when all arguments
are provided.
"""
args = munch.Munch(
{
"group_name": "foob",
"display": "foo group",
"description": None,
"username": "pingou",
}
)
pagure.cli.admin.do_new_group(args)
groups = pagure.lib.query.search_groups(self.session)
self.assertEqual(len(groups), 1)
@patch.dict("pagure.config.config", {"ENABLE_GROUP_MNGT": False})
@patch("pagure.cli.admin._ask_confirmation")
def test_new_group_grp_mngt_off_no(self, conf):
""" Test the new-group function of pagure-admin when all arguments
are provided and ENABLE_GROUP_MNGT if off in the config and the user
replies no to the question.
"""
conf.return_value = False
args = munch.Munch(
{
"group_name": "foob",
"display": "foo group",
"description": None,
"username": "pingou",
}
)
pagure.cli.admin.do_new_group(args)
groups = pagure.lib.query.search_groups(self.session)
self.assertEqual(len(groups), 0)
@patch.dict("pagure.config.config", {"ENABLE_GROUP_MNGT": False})
@patch("pagure.cli.admin._ask_confirmation")
def test_new_group_grp_mngt_off_yes(self, conf):
""" Test the new-group function of pagure-admin when all arguments
are provided and ENABLE_GROUP_MNGT if off in the config and the user
replies yes to the question.
"""
conf.return_value = True
args = munch.Munch(
{
"group_name": "foob",
"display": "foo group",
"description": None,
"username": "pingou",
}
)
pagure.cli.admin.do_new_group(args)
groups = pagure.lib.query.search_groups(self.session)
self.assertEqual(len(groups), 1)
@patch.dict("pagure.config.config", {"BLACKLISTED_GROUPS": ["foob"]})
def test_new_group_grp_mngt_off_yes(self):
""" Test the new-group function of pagure-admin when all arguments
are provided but the group is black listed.
"""
args = munch.Munch(
{
"group_name": "foob",
"display": "foo group",
"description": None,
"username": "pingou",
}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_new_group(args)
self.assertEqual(
cm.exception.args[0],
"This group name has been blacklisted, please choose another one",
)
groups = pagure.lib.query.search_groups(self.session)
self.assertEqual(len(groups), 0)
class PagureListGroupEmptyTests(tests.Modeltests):
""" Tests for pagure-admin list-groups """
populate_db = False
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureListGroupEmptyTests, self).setUp()
pagure.cli.admin.session = self.session
# Create the user pingou
item = pagure.lib.model.User(
user="pingou",
fullname="PY C",
password="foo",
default_email="bar@pingou.com",
)
self.session.add(item)
item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")
self.session.add(item)
self.session.commit()
# Make the imported pagure use the correct db session
pagure.cli.admin.session = self.session
groups = pagure.lib.query.search_groups(self.session)
self.assertEqual(len(groups), 0)
@patch("sys.stdout", new_callable=StringIO)
def test_no_groups(self, mock_stdout):
""" Test the list-groups function of pagure-admin when there are no
groups in the database
"""
args = munch.Munch()
pagure.cli.admin.do_list_groups(args)
self.assertEqual(
mock_stdout.getvalue(),
"No groups found in this pagure instance.\n",
)
groups = pagure.lib.query.search_groups(self.session)
self.assertEqual(len(groups), 0)
class PagureListGroupTests(tests.Modeltests):
""" Tests for pagure-admin list-groups """
populate_db = False
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureListGroupTests, self).setUp()
pagure.cli.admin.session = self.session
# Create the user pingou
item = pagure.lib.model.User(
user="pingou",
fullname="PY C",
password="foo",
default_email="bar@pingou.com",
)
self.session.add(item)
item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")
self.session.add(item)
# Create a group
pagure.lib.query.add_group(
self.session,
group_name="JL",
display_name="Justice League",
description="Nope, it's not JLA anymore",
group_type="user",
user="pingou",
is_admin=False,
blacklist=[],
)
self.session.commit()
# Make the imported pagure use the correct db session
pagure.cli.admin.session = self.session
groups = pagure.lib.query.search_groups(self.session)
self.assertEqual(len(groups), 1)
@patch("sys.stdout", new_callable=StringIO)
def test_list_groups(self, mock_stdout):
""" Test the list-groups function of pagure-admin when there is one
group in the database
"""
args = munch.Munch()
pagure.cli.admin.do_list_groups(args)
self.assertEqual(
mock_stdout.getvalue(),
"List of groups on this Pagure instance:\n" "Group: 1 - name JL\n",
)
groups = pagure.lib.query.search_groups(self.session)
self.assertEqual(len(groups), 1)
class PagureBlockUserTests(tests.Modeltests):
""" Tests for pagure-admin block-user """
populate_db = False
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureBlockUserTests, self).setUp()
pagure.cli.admin.session = self.session
# Create the user pingou
item = pagure.lib.model.User(
user="pingou",
fullname="PY C",
password="foo",
default_email="bar@pingou.com",
)
self.session.add(item)
item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")
self.session.add(item)
self.session.commit()
# Make the imported pagure use the correct db session
pagure.cli.admin.session = self.session
user = pagure.lib.query.get_user(self.session, "pingou")
self.assertIsNone(user.refuse_sessions_before)
def test_missing_date(self):
""" Test the block-user function of pagure-admin when the no date is
provided.
"""
args = munch.Munch({"username": "pingou", "date": None, "list": False})
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_block_user(args)
self.assertEqual(
cm.exception.args[0],
"Invalid date submitted: None, not of the format YYYY-MM-DD",
)
user = pagure.lib.query.get_user(self.session, "pingou")
self.assertIsNone(user.refuse_sessions_before)
def test_missing_username(self):
""" Test the block-user function of pagure-admin when the username
is missing from the args.
"""
args = munch.Munch(
{"date": "2018-06-11", "username": None, "list": False}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_block_user(args)
self.assertEqual(cm.exception.args[0], "An username must be specified")
user = pagure.lib.query.get_user(self.session, "pingou")
self.assertIsNone(user.refuse_sessions_before)
def test_invalid_username(self):
""" Test the block-user function of pagure-admin when the username
provided does correspond to any user in the DB.
"""
args = munch.Munch(
{"date": "2018-06-11", "username": "invalid", "list": False}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_block_user(args)
self.assertEqual(cm.exception.args[0], 'No user "invalid" found')
user = pagure.lib.query.get_user(self.session, "pingou")
self.assertIsNone(user.refuse_sessions_before)
def test_invalide_date(self):
""" Test the block-user function of pagure-admin when the provided
date is incorrect.
"""
args = munch.Munch(
{"date": "2018-14-05", "username": "pingou", "list": False}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_block_user(args)
self.assertEqual(
cm.exception.args[0],
"Invalid date submitted: 2018-14-05, not of the format YYYY-MM-DD",
)
user = pagure.lib.query.get_user(self.session, "pingou")
self.assertIsNone(user.refuse_sessions_before)
@patch("pagure.cli.admin._ask_confirmation", MagicMock(return_value=True))
def test_block_user(self):
""" Test the block-user function of pagure-admin when all arguments
are provided correctly.
"""
args = munch.Munch(
{"date": "2050-12-31", "username": "pingou", "list": False}
)
pagure.cli.admin.do_block_user(args)
user = pagure.lib.query.get_user(self.session, "pingou")
self.assertIsNotNone(user.refuse_sessions_before)
def test_list_blocked_user(self):
""" Test the block-user function of pagure-admin when all arguments
are provided correctly.
"""
args = munch.Munch({"list": True, "username": None, "date": None})
with tests.capture_output() as output:
pagure.cli.admin.do_block_user(args)
output = output.getvalue()
self.assertEqual("No users are currently blocked\n", output)
@patch("pagure.cli.admin._ask_confirmation", MagicMock(return_value=True))
def test_list_blocked_user_with_data(self):
""" Test the block-user function of pagure-admin when all arguments
are provided correctly.
"""
args = munch.Munch(
{"date": "2050-12-31", "username": "pingou", "list": False}
)
pagure.cli.admin.do_block_user(args)
args = munch.Munch({"list": True, "username": None, "date": None})
with tests.capture_output() as output:
pagure.cli.admin.do_block_user(args)
output = output.getvalue()
self.assertEqual(
"Users blocked:\n"
" pingou - 2050-12-31T00:00:00\n",
output,
)
@patch("pagure.cli.admin._ask_confirmation", MagicMock(return_value=True))
def test_list_blocked_user_with_username_data(self):
""" Test the block-user function of pagure-admin when all arguments
are provided correctly.
"""
args = munch.Munch(
{"date": "2050-12-31", "username": "pingou", "list": False}
)
pagure.cli.admin.do_block_user(args)
args = munch.Munch({"list": True, "username": "ralph", "date": None})
with tests.capture_output() as output:
pagure.cli.admin.do_block_user(args)
output = output.getvalue()
self.assertEqual("No users are currently blocked\n", output)
args = munch.Munch({"list": True, "username": "pin*", "date": None})
with tests.capture_output() as output:
pagure.cli.admin.do_block_user(args)
output = output.getvalue()
self.assertEqual(
"Users blocked:\n"
" pingou - 2050-12-31T00:00:00\n",
output,
)
@patch("pagure.cli.admin._ask_confirmation", MagicMock(return_value=True))
def test_list_blocked_user_with_date(self):
""" Test the block-user function of pagure-admin when all arguments
are provided correctly.
"""
args = munch.Munch(
{"list": True, "username": None, "date": "2050-12-31"}
)
with tests.capture_output() as output:
pagure.cli.admin.do_block_user(args)
output = output.getvalue()
self.assertIn("No users are currently blocked\n", output)
@patch("pagure.cli.admin._ask_confirmation", MagicMock(return_value=True))
def test_list_blocked_user_with_date_and_data(self):
""" Test the block-user function of pagure-admin when all arguments
are provided correctly.
"""
args = munch.Munch(
{"date": "2050-12-31", "username": "pingou", "list": False}
)
pagure.cli.admin.do_block_user(args)
args = munch.Munch(
{"list": True, "username": None, "date": "2050-12-31"}
)
with tests.capture_output() as output:
pagure.cli.admin.do_block_user(args)
output = output.getvalue()
self.assertIn(
"Users blocked:\n"
" pingou - 2050-12-31T00:00:00\n",
output,
)
args = munch.Munch(
{"list": True, "username": None, "date": "2051-01-01"}
)
with tests.capture_output() as output:
pagure.cli.admin.do_block_user(args)
output = output.getvalue()
self.assertIn("No users are currently blocked\n", output)
class PagureAdminDeleteProjectTests(tests.Modeltests):
""" Tests for pagure-admin delete-project """
populate_db = False
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureAdminDeleteProjectTests, self).setUp()
pagure.cli.admin.session = self.session
# Create the user pingou
item = pagure.lib.model.User(
user="pingou",
fullname="PY C",
password="foo",
default_email="bar@pingou.com",
)
self.session.add(item)
item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")
self.session.add(item)
# Create two projects for the user pingou
item = pagure.lib.model.Project(
user_id=1, # pingou
name="test",
description="namespaced test project",
hook_token="aaabbbeee",
namespace="somenamespace",
)
self.session.add(item)
item = pagure.lib.model.Project(
user_id=1, # pingou
name="test",
description="Test project",
hook_token="aaabbbccc",
namespace=None,
)
self.session.add(item)
self.session.commit()
# Make the imported pagure use the correct db session
pagure.cli.admin.session = self.session
def test_delete_project_unknown_project(self):
""" Test the read-only function of pagure-admin on an unknown
project.
"""
args = munch.Munch(
{"project": "foob", "user": None, "action_user": "pingou"}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_delete_project(args)
self.assertEqual(cm.exception.args[0], "No project found with: foob")
def test_delete_project_invalid_project(self):
""" Test the read-only function of pagure-admin on an invalid
project.
"""
args = munch.Munch(
{"project": "fo/o/b", "user": None, "action_user": "pingou"}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_delete_project(args)
self.assertEqual(
cm.exception.args[0],
'Invalid project name, has more than one "/": fo/o/b',
)
@patch("pagure.cli.admin._ask_confirmation", MagicMock(return_value=True))
def test_delete_project(self):
""" Test the read-only function of pagure-admin to get status of
a non-namespaced project.
"""
args = munch.Munch(
{"project": "test", "user": None, "action_user": "pingou"}
)
with tests.capture_output() as output:
pagure.cli.admin.do_delete_project(args)
output = output.getvalue()
self.assertEqual(
"Are you sure you want to delete: test?\n"
" This cannot be undone!\n"
"Project deleted\n",
output,
)
@patch("pagure.cli.admin._ask_confirmation", MagicMock(return_value=True))
def test_delete_project_namespace(self):
""" Test the read-only function of pagure-admin to get status of
a namespaced project.
"""
args = munch.Munch(
{
"project": "somenamespace/test",
"user": None,
"action_user": "pingou",
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_delete_project(args)
output = output.getvalue()
self.assertEqual(
"Are you sure you want to delete: somenamespace/test?\n"
" This cannot be undone!\n"
"Project deleted\n",
output,
)
@patch("pagure.cli.admin._ask_confirmation", MagicMock(return_value=True))
def test_delete_project_namespace_changed(self):
""" Test the read-only function of pagure-admin to set the status of
a namespaced project.
"""
# Before
projects = pagure.lib.query.search_projects(self.session)
self.assertEqual(len(projects), 2)
args = munch.Munch(
{
"project": "somenamespace/test",
"user": None,
"action_user": "pingou",
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_delete_project(args)
output = output.getvalue()
self.assertEqual(
"Are you sure you want to delete: somenamespace/test?\n"
" This cannot be undone!\n"
"Project deleted\n",
output,
)
# After
projects = pagure.lib.query.search_projects(self.session)
self.assertEqual(len(projects), 1)
class PagureCreateBranchTests(tests.Modeltests):
""" Tests for pagure-admin create-branch """
populate_db = True
def setUp(self):
""" Set up the environnment, ran before every tests. """
super(PagureCreateBranchTests, self).setUp()
# Create a couple of projects
tests.create_projects(self.session)
# Create their git repo
tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)
# Make the imported pagure use the correct db session
pagure.cli.admin.session = self.session
def test_create_branch_unknown_project(self):
""" Test the read-only function of pagure-admin on an unknown
project.
"""
args = munch.Munch(
{
"project": "foob",
"user": None,
"new_branch": "new_branch",
"from_branch": "master",
"from_commit": None,
"action_user": "pingou",
}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_create_branch(args)
self.assertEqual(
cm.exception.args[0], "No project found with: foob, user: None"
)
def test_create_branch_invalid_project(self):
""" Test the read-only function of pagure-admin on an invalid
project.
"""
args = munch.Munch(
{
"project": "f/o/o/b",
"user": None,
"new_branch": "new_branch",
"from_branch": "master",
"from_commit": None,
"action_user": "pingou",
}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_create_branch(args)
self.assertEqual(
cm.exception.args[0],
'Invalid project name, has more than one "/": f/o/o/b',
)
def test_create_branch_commit_and_branch_from(self):
""" Test the read-only function of pagure-admin to get status of
a non-namespaced project.
"""
args = munch.Munch(
{
"project": "test",
"user": None,
"new_branch": "new_branch",
"from_branch": "master",
"from_commit": "foobar",
"action_user": "pingou",
}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_create_branch(args)
self.assertEqual(
cm.exception.args[0],
"You must create the branch from something, either a commit "
"or another branch, not from both",
)
def test_create_branch_no_branch_from(self):
""" Test the read-only function of pagure-admin to get status of
a non-namespaced project.
"""
args = munch.Munch(
{
"project": "test",
"user": None,
"new_branch": "new_branch",
"from_branch": "master",
"from_commit": None,
"action_user": "pingou",
}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_create_branch(args)
self.assertEqual(
cm.exception.args[0], 'The "master" branch does not exist'
)
def test_create_branch_no_commit_from(self):
""" Test the read-only function of pagure-admin to get status of
a non-namespaced project.
"""
args = munch.Munch(
{
"project": "test",
"user": None,
"new_branch": "new_branch",
"from_branch": None,
"from_commit": "foobar",
"action_user": "pingou",
}
)
with self.assertRaises(pagure.exceptions.PagureException) as cm:
pagure.cli.admin.do_create_branch(args)
self.assertEqual(
cm.exception.args[0], "No commit foobar found from which to branch"
)
def test_create_branch_from_branch(self):
""" Test the do_create_admin_token function of pagure-admin. """
gitrepo_path = os.path.join(self.path, "repos", "test.git")
tests.add_content_git_repo(gitrepo_path)
# Check branch before:
gitrepo = pygit2.Repository(gitrepo_path)
self.assertEqual(gitrepo.listall_branches(), ["master"])
args = munch.Munch(
{
"project": "test",
"user": None,
"new_branch": "new_branch",
"from_branch": "master",
"from_commit": None,
"action_user": "pingou",
}
)
with tests.capture_output() as output:
pagure.cli.admin.do_create_branch(args)
output = output.getvalue()
self.assertEqual("Branch created\n", output)
# Check branch after:
gitrepo = pygit2.Repository(gitrepo_path)
self.assertEqual(
sorted(gitrepo.listall_branches()), ["master", "new_branch"]
)
if __name__ == "__main__":
unittest.main(verbosity=2)