toddlers/tests/plugins/test_check_commit_rights.py

from unittest.mock import Mock, patch

import fedora_messaging.api
import pytest

import toddlers.plugins.check_commit_rights


@pytest.fixture
def toddler_config():
    return {
        "exclude_users": "[]",
        "notify_emails": "[]",
        "admin_email": "foo@bar",
        "mail_server": "127.0.0.1",
        "dist_git_url": "https://src.fedoraproject.org",
    }


class TestCheckCommitRightsToddler:
    toddler_cls = toddlers.plugins.check_commit_rights.CheckCommitRights

    def test_accepts_topic_invalid(self, toddler):
        assert toddler.accepts_topic("foo.bar") is False

    @pytest.mark.parametrize(
        "topic",
        [
            "org.fedoraproject.*.toddlers.trigger.check_commit_rights",
            "org.fedoraproject.prod.toddlers.trigger.check_commit_rights",
            "org.fedoraproject.stg.toddlers.trigger.check_commit_rights",
        ],
    )
    def test_accepts_topic_valid(self, topic, toddler):
        assert toddler.accepts_topic(topic)

    def test_process_config_missing_exclude_users(self, toddler):
        msg = fedora_messaging.api.Message()
        msg.id = 123
        msg.topic = "org.fedoraproject.prod.toddlers.trigger.check_commit_rights"
        msg.body = {"foo": "bar"}

        with pytest.raises(
            Exception,
            match=r"Invalid toddler configuration, no `exclude_users` defined",
        ):
            assert toddler.process(config={}, message=msg) is None

    def test_process_config_missing_notify_emails(self, toddler):
        msg = fedora_messaging.api.Message()
        msg.id = 123
        msg.topic = "org.fedoraproject.prod.toddlers.trigger.check_commit_rights"
        msg.body = {"foo": "bar"}

        with pytest.raises(
            Exception,
            match=r"Invalid toddler configuration, no `notify_emails` defined",
        ):
            assert toddler.process(config={"exclude_users": []}, message=msg) is None

    @patch("toddlers.utils.fedora_account.set_fasjson", new=Mock(return_value=True))
    @patch("toddlers.utils.fedora_account.get_group_member")
    def test_process_no_fas(self, get_group_member, toddler, toddler_config):
        get_group_member.return_value = []

        msg = fedora_messaging.api.Message()
        msg.id = 123
        msg.topic = "org.fedoraproject.prod.toddlers.trigger.check_commit_rights"
        msg.body = {"foo": "bar"}

        with pytest.raises(
            Exception,
            match=r"Something wrong occurred, I found no packagers. Exiting.",
        ):
            toddler.process(config=toddler_config, message=msg, send_email=False)

    @patch("toddlers.utils.fedora_account.set_fasjson", new=Mock(return_value=True))
    @patch("toddlers.plugins.check_commit_rights._log.info")
    @patch("toddlers.utils.notify.send_email")
    @patch("toddlers.utils.fedora_account.get_group_member")
    def test_process_all_right(
        self, get_group_member, send_email, info, toddler, toddler_config
    ):
        req_json = {
            "pagination": {
                "page": 1,
                "pages": 1,
                "per_page": 1,
            },
            "projects": [
                {
                    "access_users": {
                        "admin": ["admin_user", "packager_user"],
                        "collaborator": ["collaborator_user"],
                        "commit": ["commit_user"],
                        "owner": ["owner_user"],
                    },
                    "fullname": "rpms/project_one",
                }
            ],
        }

        req = Mock()
        req.ok = True
        req.json.return_value = req_json
        toddler.requests_session.get.return_value = req

        get_group_member.return_value = ["packager_user"]

        msg = fedora_messaging.api.Message()
        msg.id = 123
        msg.topic = "org.fedoraproject.prod.toddlers.trigger.check_commit_rights"
        msg.body = {"foo": "bar"}

        assert toddler.process(config=toddler_config, message=msg) is None
        info.assert_any_call(
            "### Found 4 users with commit privileges but not in packager group ###"
        )
        info.assert_any_call("admin_user")
        info.assert_any_call("collaborator_user")
        info.assert_any_call("commit_user")
        info.assert_any_call("owner_user")
        with pytest.raises(AssertionError):
            info.assert_any_call("packager_user")
        send_email.assert_called()

    @patch("toddlers.utils.fedora_account.set_fasjson", new=Mock(return_value=True))
    @patch("toddlers.plugins.check_commit_rights._log.info")
    @patch("toddlers.utils.notify.send_email")
    @patch("toddlers.utils.fedora_account.get_group_member")
    def test_process_all_right_multiple_pages(
        self, get_group_member, send_email, info, toddler, toddler_config
    ):
        req_json = [
            {
                "pagination": {
                    "page": 1,
                    "pages": 2,
                    "per_page": 1,
                },
                "projects": [
                    {
                        "access_users": {
                            "admin": ["admin_user", "packager_user"],
                            "collaborator": [],
                            "commit": [],
                            "owner": [],
                        },
                        "fullname": "rpms/project_one",
                    }
                ],
            },
            {
                "pagination": {
                    "page": 2,
                    "pages": 2,
                    "per_page": 1,
                },
                "projects": [
                    {
                        "access_users": {
                            "admin": [],
                            "collaborator": [],
                            "commit": [],
                            "owner": ["owner_user"],
                        },
                        "fullname": "rpms/project_two",
                    }
                ],
            },
        ]

        req = Mock()
        req.ok = True
        req.json.side_effect = req_json
        toddler.requests_session.get.return_value = req

        get_group_member.return_value = ["packager_user"]

        msg = fedora_messaging.api.Message()
        msg.id = 123
        msg.topic = "org.fedoraproject.prod.toddlers.trigger.check_commit_rights"
        msg.body = {"foo": "bar"}

        assert toddler.process(config=toddler_config, message=msg) is None
        info.assert_any_call(
            "### Found 2 users with commit privileges but not in packager group ###"
        )
        info.assert_any_call("admin_user")
        info.assert_any_call("owner_user")
        with pytest.raises(AssertionError):
            info.assert_any_call("packager_user")
        send_email.assert_called()

    @patch("toddlers.utils.fedora_account.set_fasjson", new=Mock(return_value=True))
    @patch("toddlers.plugins.check_commit_rights._log.info")
    @patch("toddlers.utils.notify.send_email")
    @patch("toddlers.utils.fedora_account.get_group_member")
    def test_process_exclude_user(
        self, get_group_member, send_email, info, toddler, toddler_config
    ):
        req_json = {
            "pagination": {
                "page": 1,
                "pages": 1,
                "per_page": 1,
            },
            "projects": [
                {
                    "access_users": {
                        "admin": ["admin_user", "packager_user"],
                        "collaborator": ["collaborator_user"],
                        "commit": ["commit_user"],
                        "owner": ["owner_user"],
                    },
                    "fullname": "rpms/project_one",
                }
            ],
        }

        req = Mock()
        req.ok = True
        req.json.return_value = req_json
        toddler.requests_session.get.return_value = req

        get_group_member.return_value = ["packager_user"]

        msg = fedora_messaging.api.Message()
        msg.id = 123
        msg.topic = "org.fedoraproject.prod.toddlers.trigger.check_commit_rights"
        msg.body = {"foo": "bar"}

        toddler_config["exclude_users"] = ["admin_user"]

        assert toddler.process(config=toddler_config, message=msg) is None
        info.assert_any_call(
            "### Found 3 users with commit privileges but not in packager group ###"
        )
        info.assert_any_call("collaborator_user")
        info.assert_any_call("commit_user")
        info.assert_any_call("owner_user")
        with pytest.raises(AssertionError):
            info.assert_any_call("admin_user")
        send_email.assert_called()

    @patch("toddlers.utils.fedora_account.set_fasjson", new=Mock(return_value=True))
    @patch("toddlers.plugins.check_commit_rights._log.info")
    @patch("toddlers.utils.notify.send_email")
    @patch("toddlers.utils.fedora_account.get_group_member")
    def test_process_no_result(
        self, get_group_member, send_email, info, toddler, toddler_config
    ):
        req_json = {
            "pagination": {
                "page": 1,
                "pages": 1,
                "per_page": 1,
            },
            "projects": [
                {
                    "access_users": {
                        "admin": ["packager_user"],
                        "collaborator": [],
                        "commit": [],
                        "owner": ["packager_user"],
                    },
                    "fullname": "rpms/project_one",
                }
            ],
        }

        req = Mock()
        req.ok = True
        req.json.return_value = req_json
        toddler.requests_session.get.return_value = req

        get_group_member.return_value = ["packager_user"]

        msg = fedora_messaging.api.Message()
        msg.id = 123
        msg.topic = "org.fedoraproject.prod.toddlers.trigger.check_commit_rights"
        msg.body = {"foo": "bar"}

        assert toddler.process(config=toddler_config, message=msg) is None
        info.assert_any_call(
            "### Found 0 users with commit privileges but not in packager group ###"
        )
        send_email.assert_not_called()

    def test_main_no_args(self, capsys):
        with pytest.raises(SystemExit):
            toddlers.plugins.check_commit_rights.main([])

        out, err = capsys.readouterr()
        assert out == ""
        # Expecting something along these lines, but don't make the test too tight:
        #
        # usage: pytest [-h] [--dry-run] [-q | --debug] conf [username]
        # pytest: error: the following arguments are required: conf
        assert err.startswith("usage:")
        assert "error: the following arguments are required:" in err

    @patch("toml.load", new=Mock(return_value={}))
    def test_main_no_exclude_users(self, capsys):
        with pytest.raises(
            Exception,
            match=r"Invalid toddler configuration, no `exclude_users` defined",
        ):
            toddlers.plugins.check_commit_rights.main(["test.cfg"])
        out, err = capsys.readouterr()
        assert out == ""
        assert err == ""