matrix-alertbot/tests/test_command.py

import unittest
from typing import Dict, List
from unittest.mock import MagicMock, Mock, call, patch

import nio
from diskcache import Cache

import matrix_alertbot.callback
from matrix_alertbot.alertmanager import AlertmanagerClient
from matrix_alertbot.command import Command
from matrix_alertbot.errors import AlertmanagerError

from tests.utils import make_awaitable


async def create_silence_raise_alert_manager_error(
    fingerprint: str, duration: str, user: str
) -> str:
    if fingerprint == "fingerprint1":
        raise AlertmanagerError
    return "silence1"


async def create_silence_raise_alertmanager_error(
    fingerprint: str, duration: str, user: str
) -> str:
    if fingerprint == "fingerprint1":
        raise AlertmanagerError
    return "silence2"


async def delete_silence_raise_alertmanager_error(fingerprint: str) -> List[str]:
    if fingerprint == "fingerprint1":
        raise AlertmanagerError
    return ["silence1"]


class CommandTestCase(unittest.IsolatedAsyncioTestCase):
    def setUp(self) -> None:
        # Create a Command object and give it some Mock'd objects to use
        self.fake_client = Mock(spec=nio.AsyncClient)
        self.fake_client.user = "@fake_user:example.com"
        # Pretend that attempting to send a message is always successful
        self.fake_client.room_send.return_value = make_awaitable(None)

        self.fake_fingerprints = ["fingerprint1", "fingerprint2"]
        self.fake_silences = ["silence1", "silence2"]

        self.fake_cache = MagicMock(spec=Cache)
        self.fake_cache.__getitem__ = Mock(return_value=self.fake_fingerprints)

        self.fake_alertmanager = Mock(spec=AlertmanagerClient)
        self.fake_alertmanager.delete_silences.return_value = self.fake_silences

        # Create a fake room to play with
        self.fake_room = Mock(spec=nio.MatrixRoom)
        self.fake_room.room_id = "!abcdefg:example.com"
        self.fake_room.display_name = "Fake Room"
        self.fake_room.user_name.side_effect = lambda x: x

        self.fake_source_not_in_reply: Dict = {"content": {}}
        self.fake_source_in_reply: Dict = {
            "content": {
                "m.relates_to": {"m.in_reply_to": {"event_id": "some event id"}}
            }
        }

        self.fake_message_event = Mock(spec=nio.RoomMessageText)
        self.fake_message_event.sender = "@some_other_fake_user:example.com"
        self.fake_message_event.body = ""

        # We don't spec config, as it doesn't currently have well defined attributes
        self.fake_config = Mock()
        self.fake_config.room_id = self.fake_room.room_id
        self.fake_config.command_prefix = "!alert "

    @patch.object(matrix_alertbot.command.Command, "_ack")
    async def test_process_ack_command(self, fake_ack: Mock) -> None:
        """Tests the callback for InviteMemberEvents"""
        # Tests that the bot attempts to join a room after being invited to it

        command = Command(
            self.fake_client,
            self.fake_cache,
            self.fake_alertmanager,
            self.fake_config,
            "ack",
            self.fake_room,
            self.fake_message_event,
        )
        await command.process()

        # Check that we attempted to process the command
        fake_ack.assert_called_once()

    @patch.object(matrix_alertbot.command.Command, "_unack")
    async def test_process_unack_command(self, fake_unack: Mock) -> None:
        """Tests the callback for InviteMemberEvents"""
        # Tests that the bot attempts to join a room after being invited to it

        for command_word in ("unack", "nack"):
            command = Command(
                self.fake_client,
                self.fake_cache,
                self.fake_alertmanager,
                self.fake_config,
                command_word,
                self.fake_room,
                self.fake_message_event,
            )
            await command.process()

        # Check that we attempted to process the command
        fake_unack.assert_has_calls([call(), call()])

    @patch.object(matrix_alertbot.command.Command, "_show_help")
    async def test_process_help_command(self, fake_help: Mock) -> None:
        """Tests the callback for InviteMemberEvents"""
        # Tests that the bot attempts to join a room after being invited to it

        command = Command(
            self.fake_client,
            self.fake_cache,
            self.fake_alertmanager,
            self.fake_config,
            "help",
            self.fake_room,
            self.fake_message_event,
        )
        await command.process()

        # Check that we attempted to process the command
        fake_help.assert_called_once()

    @patch.object(matrix_alertbot.command.Command, "_unknown_command")
    async def test_process_unknown_command(self, fake_unknown: Mock) -> None:
        """Tests the callback for InviteMemberEvents"""
        # Tests that the bot attempts to join a room after being invited to it

        command = Command(
            self.fake_client,
            self.fake_cache,
            self.fake_alertmanager,
            self.fake_config,
            "",
            self.fake_room,
            self.fake_message_event,
        )
        await command.process()

        # Check that we attempted to process the command
        fake_unknown.assert_called_once()

    async def test_ack_not_in_reply_without_duration(self) -> None:
        """Tests the callback for InviteMemberEvents"""
        # Tests that the bot attempts to join a room after being invited to it

        self.fake_message_event.source = self.fake_source_not_in_reply

        command = Command(
            self.fake_client,
            self.fake_cache,
            self.fake_alertmanager,
            self.fake_config,
            "ack",
            self.fake_room,
            self.fake_message_event,
        )
        await command._ack()

        # Check that we didn't attempt to create silences
        self.fake_alertmanager.create_silence.assert_not_called()
        self.fake_client.room_send.assert_not_called()

    async def test_ack_not_in_reply_with_duration(self) -> None:
        """Tests the callback for InviteMemberEvents"""
        # Tests that the bot attempts to join a room after being invited to it

        self.fake_message_event.source = self.fake_source_not_in_reply

        command = Command(
            self.fake_client,
            self.fake_cache,
            self.fake_alertmanager,
            self.fake_config,
            "ack 2d",
            self.fake_room,
            self.fake_message_event,
        )
        await command._ack()

        # Check that we didn't attempt to create silences
        self.fake_alertmanager.create_silence.assert_not_called()
        self.fake_client.room_send.assert_not_called()

    @patch.object(matrix_alertbot.command, "send_text_to_room")
    async def test_ack_in_reply_without_duration(
        self, fake_send_text_to_room: Mock
    ) -> None:
        """Tests the callback for InviteMemberEvents"""
        # Tests that the bot attempts to join a room after being invited to it

        self.fake_message_event.source = self.fake_source_in_reply

        command = Command(
            self.fake_client,
            self.fake_cache,
            self.fake_alertmanager,
            self.fake_config,
            "ack",
            self.fake_room,
            self.fake_message_event,
        )
        await command._ack()

        # Check that we attempted to create silences
        self.fake_alertmanager.create_silence.assert_has_calls(
            [
                call(
                    fingerprint,
                    "1d",
                    self.fake_message_event.sender,
                )
                for fingerprint in self.fake_fingerprints
            ]
        )
        fake_send_text_to_room.assert_called_once_with(
            self.fake_client,
            self.fake_room.room_id,
            "Created 2 silences with a duration of 1d.",
        )

    @patch.object(matrix_alertbot.command, "send_text_to_room")
    async def test_ack_in_reply_with_duration(
        self, fake_send_text_to_room: Mock
    ) -> None:
        """Tests the callback for InviteMemberEvents"""
        # Tests that the bot attempts to join a room after being invited to it

        self.fake_message_event.source = self.fake_source_in_reply

        command = Command(
            self.fake_client,
            self.fake_cache,
            self.fake_alertmanager,
            self.fake_config,
            "ack 2d",
            self.fake_room,
            self.fake_message_event,
        )
        await command._ack()

        # Check that we attempted to create silences
        self.fake_alertmanager.create_silence.assert_has_calls(
            [
                call(
                    fingerprint,
                    "2d",
                    self.fake_message_event.sender,
                )
                for fingerprint in self.fake_fingerprints
            ]
        )
        fake_send_text_to_room.assert_called_once_with(
            self.fake_client,
            self.fake_room.room_id,
            "Created 2 silences with a duration of 2d.",
        )

    @patch.object(matrix_alertbot.command, "send_text_to_room")
    async def test_ack_raise_alertmanager_error(
        self, fake_send_text_to_room: Mock
    ) -> None:
        """Tests the callback for InviteMemberEvents"""
        # Tests that the bot attempts to join a room after being invited to it

        self.fake_message_event.source = self.fake_source_in_reply

        command = Command(
            self.fake_client,
            self.fake_cache,
            self.fake_alertmanager,
            self.fake_config,
            "ack",
            self.fake_room,
            self.fake_message_event,
        )

        self.fake_alertmanager.create_silence.side_effect = (
            create_silence_raise_alertmanager_error
        )
        await command._ack()

        # Check that we attempted to create silences
        self.fake_alertmanager.create_silence.assert_has_calls(
            [
                call(
                    fingerprint,
                    "1d",
                    self.fake_message_event.sender,
                )
                for fingerprint in self.fake_fingerprints
            ]
        )
        fake_send_text_to_room.assert_called_once_with(
            self.fake_client,
            self.fake_room.room_id,
            "Created 1 silences with a duration of 1d.",
        )

    @patch.object(matrix_alertbot.command, "send_text_to_room")
    async def test_unack_in_reply(self, fake_send_text_to_room: Mock) -> None:
        """Tests the callback for InviteMemberEvents"""
        # Tests that the bot attempts to join a room after being invited to it

        self.fake_message_event.source = self.fake_source_in_reply

        command = Command(
            self.fake_client,
            self.fake_cache,
            self.fake_alertmanager,
            self.fake_config,
            "unack",
            self.fake_room,
            self.fake_message_event,
        )
        await command._unack()

        # Check that we attempted to create silences
        self.fake_alertmanager.delete_silences.assert_has_calls(
            [call(fingerprint) for fingerprint in self.fake_fingerprints]
        )
        fake_send_text_to_room.assert_called_with(
            self.fake_client, self.fake_room.room_id, "Removed 4 silences."
        )

    @patch.object(matrix_alertbot.command, "send_text_to_room")
    async def test_unack_silence_raise_alertmanager_error(
        self, fake_send_text_to_room: Mock
    ) -> None:
        """Tests the callback for InviteMemberEvents"""
        # Tests that the bot attempts to join a room after being invited to it

        self.fake_message_event.source = self.fake_source_in_reply

        command = Command(
            self.fake_client,
            self.fake_cache,
            self.fake_alertmanager,
            self.fake_config,
            "unack",
            self.fake_room,
            self.fake_message_event,
        )

        self.fake_alertmanager.delete_silences.side_effect = (
            delete_silence_raise_alertmanager_error
        )
        await command._unack()

        # Check that we attempted to create silences
        self.fake_alertmanager.delete_silences.assert_has_calls(
            [call(fingerprint) for fingerprint in self.fake_fingerprints]
        )
        fake_send_text_to_room.assert_called_with(
            self.fake_client, self.fake_room.room_id, "Removed 1 silences."
        )


if __name__ == "__main__":
    unittest.main()