toddlers/tests/utils/test_fedora_account_fasjson.py

from unittest.mock import call, Mock, patch

from fasjson_client.errors import ClientError
import pytest

import toddlers.utils.fedora_account


class TestFedoraAccountFASJSON:
    def test_set_fasjson_no_fas_url(self):
        with pytest.raises(
            ValueError, match=r"No fas_url found in the configuration file"
        ):
            toddlers.utils.fedora_account.set_fasjson({})

    @patch("toddlers.utils.fedora_account.Client")
    def test_set_fasjson(self, mock_fas):
        mock_fas.return_value = "fas_object"
        config = {
            "fas_url": "https:fas.example.com",
            "fasjson": True,
        }
        output = toddlers.utils.fedora_account.set_fasjson(config)
        mock_fas.assert_called_with(url="https:fas.example.com")
        assert output == "fas_object"

    def test_set_fasjson_error(self):
        with patch(
            "toddlers.utils.fedora_account.Client",
            side_effect=ClientError(
                message="Error communicating with fasjson to instantiate the client",
                code="404",
            ),
        ):
            with pytest.raises(
                ClientError,
                match=r"Error communicating with fasjson to instantiate the client",
            ):
                config = {
                    "fas_url": "https:fas.example.com",
                    "fasjson": True,
                }
                toddlers.utils.fedora_account.set_fasjson(config)

    @patch("toddlers.utils.fedora_account._FASJSON", new=None)
    def test_get_fasjson_not_set(self):
        with pytest.raises(
            ValueError, match=r"No FASJSON client instantiated, call set_fasjson first"
        ):
            toddlers.utils.fedora_account.get_fasjson()

    def test_get_fasjson(self):
        output = toddlers.utils.fedora_account.get_fasjson()
        assert output == "fas_object"

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_group_member(self, mock_fas):
        members = []
        for name in ["pingou", "ralph", "kevin", "nils"]:
            member = {"role_type": "administrator", "username": name}
            members.append(member)
        result = Mock()
        result.result = members
        server = Mock()
        server.list_group_members.return_value = result
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_group_member("sysadmin")
        assert output == {"kevin", "nils", "pingou", "ralph"}

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_group_member_error(self, mock_fas):
        server = Mock()
        server.list_group_members.side_effect = ClientError(
            message="Error getting list of members",
            code="500",
        )
        mock_fas.return_value = server
        output = toddlers.utils.fedora_account.get_group_member("sysadmin")
        assert output == set()

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_group_member_empty(self, mock_fas):
        members = []
        result = Mock()
        result.result = members
        server = Mock()
        server.list_group_members.return_value = result
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_group_member("sysadmin")
        assert output == set()

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_bz_email_user_no_bugzilla_email(self, mock_fas):
        result = Mock()
        result.result = {}
        server = Mock()
        server.get_user.return_value = result
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_bz_email_user("pingou", {})
        assert output is None

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_bz_email_user(self, mock_fas):
        result = Mock()
        result.result = {"rhbzemail": "foo@bar.com"}
        server = Mock()
        server.get_user.return_value = result
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_bz_email_user("pingou", {})
        assert output == "foo@bar.com"

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_bz_email_user_no_bz_email(self, mock_fas):
        """
        Test if the account e-mail will be used if Red Hat Bugzilla e-mail is not set.
        """
        result = Mock()
        result.result = {"emails": ["foo@bar.com"]}
        server = Mock()
        server.get_user.return_value = result
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_bz_email_user("pingou", {})
        assert output == "foo@bar.com"

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_bz_email_user_error(self, mock_fas):
        server = Mock()
        server.get_user.side_effect = ClientError(
            message="Error getting bz_email",
            code="500",
        )
        mock_fas.return_value = server
        output = toddlers.utils.fedora_account.get_bz_email_user("pingou", {})
        assert output is None

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_bz_email_group_no_bugzilla_email(self, mock_fas):
        result = Mock()
        result.result = {}
        server = Mock()
        server.get_group.return_value = result
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_bz_email_group("toddlers-sig", {})
        assert output is None

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_bz_email_group(self, mock_fas):
        result = Mock()
        result.result = {"mailing_list": "foo@lists.bar.com"}
        server = Mock()
        server.get_group.return_value = result
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_bz_email_group("toddlers-sig", {})
        assert output == "foo@lists.bar.com"

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_bz_email_group_error(self, mock_fas):
        server = Mock()
        server.get_group.side_effect = ClientError(
            message="Error getting bz_email for group",
            code="500",
        )
        mock_fas.return_value = server
        output = toddlers.utils.fedora_account.get_bz_email_group("sysadmin", {})
        assert output is None

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_user_by_email(self, mock_fas):
        user = [{"username": "scoady", "emails": ["scoady@fp.o"]}]
        result = Mock()
        result.result = user
        server = Mock()
        server.search.return_value = result
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_user_by_email("scoady@fp.o")
        assert output == {"username": "scoady", "emails": ["scoady@fp.o"]}

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_user_by_bzemail(self, mock_fas):
        """
        Assert that bugzilla e-mail is searched for when there is no result in
        primary e-mail.
        """
        user = [{"username": "scoady", "rhbzemail": "scoady@fp.o"}]
        empty_result = Mock()
        empty_result.result = []
        result = Mock()
        result.result = user
        server = Mock()
        server.search.side_effect = [empty_result, result]
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_user_by_email("scoady@fp.o")
        assert output == {"username": "scoady", "rhbzemail": "scoady@fp.o"}

        server.search.assert_has_calls(
            [call(email="scoady@fp.o"), call(rhbzemail__exact="scoady@fp.o")]
        )

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_user_by_email_empty(self, mock_fas):
        user = []
        result = Mock()
        result.result = user
        server = Mock()
        server.search.return_value = result
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_user_by_email("scoady@fp.o")
        assert output is None

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_user_by_email_error(self, mock_fas):
        server = Mock()
        server.search.side_effect = ClientError(
            message="Error getting bz_email for group",
            code="500",
        )
        mock_fas.return_value = server
        output = toddlers.utils.fedora_account.get_user_by_email("scoady@fp.o")
        assert output is None

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_user_member_of(self, mock_fas):
        """
        Assert that membership is correctly checked.
        """
        server = Mock()
        result = Mock()
        result.result = True
        server.check_membership.return_value = result
        mock_fas.return_value = server

        group = "group"
        user = {"username": "user"}

        output = toddlers.utils.fedora_account.user_member_of(user, group)

        server.check_membership.assert_called_with(
            groupname=group, username=user["username"]
        )
        assert output is True

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_user_member_of_error(self, mock_fas):
        """
        Assert that error is handled correctly.
        """
        server = Mock()
        server.check_membership.side_effect = ClientError(
            message="Error getting bz_email for group",
            code="500",
        )
        mock_fas.return_value = server

        group = "group"
        user = {"username": "user"}

        output = toddlers.utils.fedora_account.user_member_of(user, group)

        server.check_membership.assert_called_with(
            groupname=group, username=user["username"]
        )
        assert output is False

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_user_by_username(self, mock_fas):
        user = [{"username": "scoady", "emails": ["scoady@fp.o"]}]
        result = Mock()
        result.result = user
        server = Mock()
        server.search.return_value = result
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_user_by_username("scoady")

        server.search.assert_called_with(username="scoady")
        assert output == {"username": "scoady", "emails": ["scoady@fp.o"]}

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_user_by_username_empty(self, mock_fas):
        user = []
        result = Mock()
        result.result = user
        server = Mock()
        server.search.return_value = result
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_user_by_username("scoady")

        server.search.assert_called_with(username="scoady")
        assert output is None

    @patch("toddlers.utils.fedora_account.get_fasjson")
    def test_get_user_by_username_error(self, mock_fas):
        server = Mock()
        server.search.side_effect = ClientError(
            message="Error getting bz_email for group",
            code="500",
        )
        mock_fas.return_value = server

        output = toddlers.utils.fedora_account.get_user_by_username("scoady")

        server.search.assert_called_with(username="scoady")
        assert output is None