aa-rss-to-discord 2.3.32.3.3__py3-none-any.whl → 2.5.0__py3-none-any.whl

aa_rss_to_discord/tasks.py

@@ -3,39 +3,35 @@ AA RSS To Discord Tasks
 """
 
 # Standard Library
-import logging
 import re
 
 # Third Party
 import feedparser
-from celery import shared_task
-
-# Django
-from django.apps import apps
+from aadiscordbot.tasks import send_message
+from celery import group, shared_task
 
 # Alliance Auth
 from allianceauth.services.hooks import get_extension_logger
 from allianceauth.services.tasks import QueueOnce
 
-# Alliance Auth (External Libs)
-from app_utils.logging import LoggerAddTag
-
 # AA RSS to Discord
 from aa_rss_to_discord import __title__
+from aa_rss_to_discord.constants import USER_AGENT
 from aa_rss_to_discord.models import LastItem, RssFeeds
+from aa_rss_to_discord.providers import AppLogger
 
-logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+logger = AppLogger(get_extension_logger(__name__), __title__)
 
 
-def remove_emoji(string):
+def remove_emoji(string: str) -> str:
     """
     Removing these dumb as fuck emojis from the title string.
     Like honestly, who in the hell needs that shit?
 
-    :param string:
-    :type string:
-    :return:
-    :rtype:
+    :param string: Input string
+    :type string: str
+    :return: String without emojis
+    :rtype: str
     """
 
     emoji_pattern = re.compile(
@@ -66,142 +62,93 @@ def remove_emoji(string):
 
 
 @shared_task(**{"base": QueueOnce})
-def fetch_rss() -> None:  # pylint: disable=too-many-statements, too-many-branches
+def fetch_rss() -> None:
     """
-    Fetch RSS feeds and post to Discord
+    Fetch all enabled RSS feeds and dispatch processing tasks.
 
-    :return:
-    :rtype:
+    :return: None
+    :rtype: None
     """
 
-    # pylint: disable=too-many-nested-blocks
-    if apps.is_installed(app_name="aadiscordbot"):
-        # Third Party
-        from aadiscordbot.tasks import (  # pylint: disable=import-outside-toplevel
-            send_message,
-        )
+    rss_feeds = RssFeeds.objects.select_enabled()
+    if not rss_feeds:
+        logger.debug("No RSS feeds found to parse.")
+        return
+
+    feed_ids = [f.id for f in rss_feeds]
+    if not feed_ids:
+        logger.debug("No RSS feed ids to dispatch.")
+        return
+
+    group(_process_feed.s(fid) for fid in feed_ids).apply_async()
+
+
+@shared_task
+def _process_feed(rss_feed_id: int) -> None:
+    """
+    Process a single RSS feed by fetching its latest entry and posting to Discord if it's new.
+
+    :param rss_feed_id: ID of the RSS feed to process
+    :type rss_feed_id: int
+    :return: None
+    :rtype: None
+    """
 
-        rss_feeds = RssFeeds.objects.select_enabled()
-
-        if rss_feeds:
-            for rss_feed in rss_feeds:
-                logger.info(msg=f'Fetching RSS Feed "{rss_feed.name}"')
-
-                feed = feedparser.parse(url_file_stream_or_string=rss_feed.url)
-
-                feed_entry_title = "No title"
-                feed_entry_link = None
-                feed_entry_time = None
-                feed_entry_guid = None
-                has_last_item = False
-                last_item = None
-                post_entry = False
-
-                try:
-                    latest_entry = feed.entries[0]
-
-                    feed_entry_title = remove_emoji(
-                        string=latest_entry.get("title", "No title")
-                    )
-                    feed_entry_link = latest_entry.get("link", None)
-                    feed_entry_time = latest_entry.get(
-                        "published", latest_entry.updated
-                    )
-                    feed_entry_guid = latest_entry.get("id", None)
-                except AttributeError as exc:
-                    logger.debug(
-                        msg=f'Malformed RSS feed item in feed "{rss_feed.name}". Error: {exc}'
-                    )
-                except IndexError as exc:
-                    logger.debug(
-                        msg=f'Could not index the RSS feed "{rss_feed.name}". Error: {exc}'
-                    )
-                else:
-                    post_entry = True
-                    has_last_item = True
-
-                    try:
-                        last_item = LastItem.objects.get(rss_feed=rss_feed)
-
-                        if (
-                            last_item
-                            and last_item.rss_item_time == feed_entry_time
-                            and last_item.rss_item_title == feed_entry_title
-                            and last_item.rss_item_link == feed_entry_link
-                            and last_item.rss_item_guid == feed_entry_guid
-                        ):
-                            logger.debug(
-                                msg=(
-                                    f'News item "{feed_entry_title}" for RSS Feed '
-                                    f'"{rss_feed.name}" has already been posted to your Discord'
-                                )
-                            )
-                            post_entry = False
-                    except LastItem.DoesNotExist:
-                        logger.debug(msg="This seems to be a completely new RSS feed.")
-
-                        has_last_item = False
-
-                logger.debug(
-                    msg=(
-                        "RSS Information gathered: "
-                        f"post_entry => {post_entry}, "
-                        f'feed_entry_link => "{feed_entry_link}", '
-                        f'feed_entry_title => "{feed_entry_title}", '
-                        f"feed_entry_time => {feed_entry_time}, "
-                        f"feed_entry_guid => {feed_entry_guid}"
-                    )
-                )
-
-                if (
-                    post_entry is True
-                    and feed_entry_link is not None
-                    and feed_entry_guid is not None
-                ):
-                    logger.info(
-                        msg=(
-                            "New entry found, posting to Discord channel "
-                            f"{rss_feed.discord_channel}"
-                        )
-                    )
-
-                    if has_last_item is True:
-                        # Update the last item ...
-                        last_item.rss_item_time = feed_entry_time
-                        last_item.rss_item_title = feed_entry_title
-                        last_item.rss_item_link = feed_entry_link
-                        last_item.rss_item_guid = feed_entry_guid
-                        last_item.save()
-                    else:
-                        # Set the last item ...
-                        LastItem(
-                            rss_feed=rss_feed,
-                            rss_item_time=feed_entry_time,
-                            rss_item_title=feed_entry_title,
-                            rss_item_link=feed_entry_link,
-                            rss_item_guid=feed_entry_guid,
-                        ).save()
-
-                    discord_message = f"**{rss_feed.name}**\n{feed_entry_link}"
-
-                    send_message(
-                        channel_id=rss_feed.discord_channel.channel,
-                        message=discord_message,
-                    )
-                else:
-                    logger.debug(
-                        msg=(
-                            f'No item for feed "{rss_feed.name}" to post. '
-                            'Missing either "post_entry" to be "True" or '
-                            'either "feed_entry_link" or "feed_entry_guid" is "None".'
-                        )
-                    )
-        else:
-            logger.debug(msg="No RSS feeds found to parse.")
-    else:
-        logging.info(
-            msg=(
-                "AA Discordbot (https://github.com/pvyParts/allianceauth-discordbot) "
-                "needs to be installed and configured."
-            )
+    try:
+        rss_feed = RssFeeds.objects.select_related("discord_channel").get(
+            id=rss_feed_id
+        )
+    except RssFeeds.DoesNotExist:
+        logger.debug("RSS feed %s not found", rss_feed_id)
+        return
+
+    logger.info(f'Fetching RSS Feed "{rss_feed.name}"')
+    feed = feedparser.parse(rss_feed.url, agent=USER_AGENT)
+
+    latest_entry = next(iter(getattr(feed, "entries", [])), None)
+    if not latest_entry:
+        logger.debug(f'No entries found for feed "{rss_feed.name}".')
+        return
+
+    feed_entry_title = remove_emoji(latest_entry.get("title", "No title"))
+    feed_entry_link = latest_entry.get("link")
+    feed_entry_time = latest_entry.get("published", latest_entry.get("updated"))
+    feed_entry_guid = latest_entry.get("id")
+
+    last_item = LastItem.objects.filter(rss_feed=rss_feed).first()
+    if last_item and (
+        last_item.rss_item_time,
+        last_item.rss_item_title,
+        last_item.rss_item_link,
+        last_item.rss_item_guid,
+    ) == (feed_entry_time, feed_entry_title, feed_entry_link, feed_entry_guid):
+        logger.debug(
+            'News item "%s" for RSS Feed "%s" has already been posted to your Discord',
+            feed_entry_title,
+            rss_feed.name,
         )
+        return
+
+    if not last_item:
+        logger.debug("This seems to be a completely new RSS feed: %s", rss_feed.name)
+
+    logger.info(
+        'New entry found for RSS feed "%s", posting to Discord channel %s',
+        rss_feed.name,
+        rss_feed.discord_channel,
+    )
+
+    LastItem.objects.update_or_create(
+        rss_feed=rss_feed,
+        defaults={
+            "rss_item_time": feed_entry_time,
+            "rss_item_title": feed_entry_title,
+            "rss_item_link": feed_entry_link,
+            "rss_item_guid": feed_entry_guid,
+        },
+    )
+
+    send_message(
+        channel_id=rss_feed.discord_channel.channel,
+        message=f"**{rss_feed.name}**\n{feed_entry_link}",
+    )

aa_rss_to_discord/tests/__init__.py

@@ -0,0 +1,41 @@
+"""
+Initialize the tests
+"""
+
+# Standard Library
+import socket
+
+# Django
+from django.test import TestCase
+
+
+class SocketAccessError(Exception):
+    """Error raised when a test script accesses the network"""
+
+
+class BaseTestCase(TestCase):
+    """Variation of Django's TestCase class that prevents any network use.
+
+    Example:
+
+        .. code-block:: python
+
+            class TestMyStuff(BaseTestCase):
+                def test_should_do_what_i_need(self): ...
+
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        cls.socket_original = socket.socket
+        socket.socket = cls.guard
+        return super().setUpClass()
+
+    @classmethod
+    def tearDownClass(cls):
+        socket.socket = cls.socket_original
+        return super().tearDownClass()
+
+    @staticmethod
+    def guard(*args, **kwargs):
+        raise SocketAccessError("Attempted to access network")

aa_rss_to_discord/tests/test_auth_hooks.py

@@ -0,0 +1,49 @@
+# Standard Library
+from unittest import mock
+
+# AA RSS to Discord
+from aa_rss_to_discord.auth_hooks import register_cogs
+from aa_rss_to_discord.tests import BaseTestCase
+
+
+class TestAuthHooks(BaseTestCase):
+    """
+    Test the auth hooks
+    """
+
+    def test_registers_discord_cogs_hook_correctly(self):
+        """
+        Tests that the discord cogs hook is registered correctly.
+
+        :return:
+        :rtype:
+        """
+
+        result = register_cogs()
+
+        self.assertIn("aa_rss_to_discord.discordbot.cogs.rss", result)
+
+    def test_returns_list_of_cogs(self):
+        """
+        Tests that the register_cogs function returns a list.
+
+        :return:
+        :rtype:
+        """
+
+        result = register_cogs()
+
+        self.assertIsInstance(result, list)
+
+    def test_handles_empty_hook_registration_gracefully(self):
+        """
+        Tests that the register_cogs function handles an empty hook registration gracefully.
+
+        :return:
+        :rtype:
+        """
+
+        with mock.patch("allianceauth.hooks.register", return_value=None):
+            result = register_cogs()
+
+            self.assertIsNotNone(result)

aa_rss_to_discord/tests/test_managers.py

@@ -0,0 +1,32 @@
+# AA RSS to Discord
+from aa_rss_to_discord.models import RssFeeds
+from aa_rss_to_discord.tests import BaseTestCase
+
+
+class TestRssFeedManager(BaseTestCase):
+    """
+    Test the RSS Feed Manager
+    """
+
+    def test_returns_only_enabled_feeds(self):
+        RssFeeds.objects.create(name="Feed 1", enabled=True)
+        RssFeeds.objects.create(name="Feed 2", enabled=False)
+        RssFeeds.objects.create(name="Feed 3", enabled=True)
+
+        result = RssFeeds.objects.select_enabled()
+
+        self.assertEqual(result.count(), 2)
+        self.assertTrue(all(feed.enabled for feed in result))
+
+    def test_handles_no_enabled_feeds_gracefully(self):
+        RssFeeds.objects.create(name="Feed 1", enabled=False)
+        RssFeeds.objects.create(name="Feed 2", enabled=False)
+
+        result = RssFeeds.objects.select_enabled()
+
+        self.assertEqual(result.count(), 0)
+
+    def test_handles_empty_database_gracefully(self):
+        result = RssFeeds.objects.select_enabled()
+
+        self.assertEqual(result.count(), 0)

aa_rss_to_discord/tests/test_models.py

@@ -0,0 +1,165 @@
+# Third Party
+from aadiscordbot.models import Channels, Servers
+
+# AA RSS to Discord
+from aa_rss_to_discord.models import LastItem, RssFeeds
+from aa_rss_to_discord.tests import BaseTestCase
+
+
+class TestRssFeeds(BaseTestCase):
+    """
+    Test the RssFeeds model.
+    """
+
+    def test_saves_and_retrieves_rss_feed_correctly(self):
+        """
+        Tests that an RSS feed can be saved and retrieved correctly.
+
+        :return:
+        :rtype:
+        """
+
+        feed = RssFeeds.objects.create(
+            name="Feed 1", url="http://example.com/rss", enabled=True
+        )
+        retrieved_feed = RssFeeds.objects.get(id=feed.id)
+
+        self.assertEqual(retrieved_feed.name, "Feed 1")
+        self.assertEqual(retrieved_feed.url, "http://example.com/rss")
+        self.assertTrue(retrieved_feed.enabled)
+
+    def test_handles_null_discord_channel_gracefully(self):
+        """
+        Tests that the model handles a null discord_channel gracefully.
+
+        :return:
+        :rtype:
+        """
+
+        feed = RssFeeds.objects.create(
+            name="Feed 2", url="http://example.com/rss", discord_channel=None
+        )
+
+        self.assertIsNone(feed.discord_channel)
+
+    def test_string_representation_includes_name_and_channel(self):
+        """
+        Tests that the string representation of the RssFeeds model
+
+        :return:
+        :rtype:
+        """
+        server = Servers.objects.create(server=1, name="Test Server")
+        channel = Channels.objects.create(name="General", server=server, channel=1)
+        feed = RssFeeds.objects.create(name="Feed 3", discord_channel=channel)
+
+        self.assertEqual(
+            str(feed), 'RSS Feed "Feed 3" for channel "General" On "Test Server"'
+        )
+
+    def test_allows_disabling_rss_feed(self):
+        """
+        Tests that an RSS feed can be disabled.
+
+        :return:
+        :rtype:
+        """
+        feed = RssFeeds.objects.create(name="Feed 4", enabled=True)
+        feed.enabled = False
+        feed.save()
+
+        updated_feed = RssFeeds.objects.get(id=feed.id)
+
+        self.assertFalse(updated_feed.enabled)
+
+    def test_handles_empty_name_and_url_gracefully(self):
+        """
+        Tests that the model handles empty name and url fields gracefully.
+
+        :return:
+        :rtype:
+        """
+
+        feed = RssFeeds.objects.create(name="", url="")
+
+        self.assertEqual(feed.name, "")
+        self.assertEqual(feed.url, "")
+
+
+class TestLastItem(BaseTestCase):
+    """
+    Test the LastItem model.
+    """
+
+    def test_string_representation_includes_item_title(self):
+        """
+        Tests that the string representation of the LastItem model includes the item title.
+
+        :return:
+        :rtype:
+        """
+
+        feed = RssFeeds.objects.create(name="Feed 1", url="http://example.com/rss")
+        item = LastItem.objects.create(
+            rss_feed=feed,
+            rss_item_title="Sample Item",
+            rss_item_link="http://example.com/item",
+        )
+
+        self.assertEqual(str(item), 'RSS Entry "Sample Item"')
+
+    def test_handles_empty_item_title_gracefully(self):
+        """
+        Tests that the model handles an empty item title gracefully.
+
+        :return:
+        :rtype:
+        """
+
+        feed = RssFeeds.objects.create(name="Feed 2", url="http://example.com/rss")
+        item = LastItem.objects.create(
+            rss_feed=feed,
+            rss_item_title="",
+            rss_item_link="http://example.com/item",
+        )
+
+        self.assertEqual(str(item), 'RSS Entry ""')
+
+    def test_saves_and_retrieves_last_item_correctly(self):
+        """
+        Tests that a LastItem can be saved and retrieved correctly.
+
+        :return:
+        :rtype:
+        """
+
+        feed = RssFeeds.objects.create(name="Feed 3", url="http://example.com/rss")
+        item = LastItem.objects.create(
+            rss_feed=feed,
+            rss_item_time="2023-10-01T12:00:00Z",
+            rss_item_title="Item Title",
+            rss_item_link="http://example.com/item",
+            rss_item_guid="12345",
+        )
+        retrieved_item = LastItem.objects.get(id=item.id)
+
+        self.assertEqual(retrieved_item.rss_item_time, "2023-10-01T12:00:00Z")
+        self.assertEqual(retrieved_item.rss_item_title, "Item Title")
+        self.assertEqual(retrieved_item.rss_item_link, "http://example.com/item")
+        self.assertEqual(retrieved_item.rss_item_guid, "12345")
+
+    def test_handles_null_guid_gracefully(self):
+        """
+        Tests that the model handles a null guid gracefully.
+
+        :return:
+        :rtype:
+        """
+
+        feed = RssFeeds.objects.create(name="Feed 4", url="http://example.com/rss")
+        item = LastItem.objects.create(
+            rss_feed=feed,
+            rss_item_guid="",
+        )
+
+        self.assertEqual(item.rss_item_guid, "")

aa_rss_to_discord/tests/test_providers.py

@@ -0,0 +1,99 @@
+"""
+Test for the providers module.
+"""
+
+# Standard Library
+import logging
+
+# AA RSS to Discord
+# AA Intel Tool
+from aa_rss_to_discord.providers import AppLogger
+from aa_rss_to_discord.tests import BaseTestCase
+
+
+class TestAppLogger(BaseTestCase):
+    """
+    Test the AppLogger provider.
+    """
+
+    def test_adds_prefix_to_log_message(self):
+        """
+        Tests that the AppLogger correctly adds a prefix to log messages.
+
+        :return:
+        :rtype:
+        """
+
+        logger = logging.getLogger("test_logger")
+        app_logger = AppLogger(logger, "PREFIX")
+
+        with self.assertLogs("test_logger", level="INFO") as log:
+            app_logger.info("This is a test message")
+
+        self.assertIn("[PREFIX] This is a test message", log.output[0])
+
+    def test_handles_empty_prefix(self):
+        """
+        Tests that the AppLogger handles an empty prefix correctly.
+
+        :return:
+        :rtype:
+        """
+
+        logger = logging.getLogger("test_logger")
+        app_logger = AppLogger(logger, "")
+
+        with self.assertLogs("test_logger", level="INFO") as log:
+            app_logger.info("Message without prefix")
+
+        self.assertIn("Message without prefix", log.output[0])
+
+    def test_handles_non_string_prefix(self):
+        """
+        Tests that the AppLogger handles a non-string prefix correctly.
+
+        :return:
+        :rtype:
+        """
+
+        logger = logging.getLogger("test_logger")
+        app_logger = AppLogger(logger, 123)
+
+        with self.assertLogs("test_logger", level="INFO") as log:
+            app_logger.info("Message with numeric prefix")
+
+        self.assertIn("[123] Message with numeric prefix", log.output[0])
+
+    def test_handles_special_characters_in_prefix(self):
+        """
+        Tests that the AppLogger handles special characters in the prefix correctly.
+
+        :return:
+        :rtype:
+        """
+
+        logger = logging.getLogger("test_logger")
+        app_logger = AppLogger(logger, "!@#$%^&*()")
+
+        with self.assertLogs("test_logger", level="INFO") as log:
+            app_logger.info("Message with special characters in prefix")
+
+        self.assertIn(
+            "[!@#$%^&*()] Message with special characters in prefix", log.output[0]
+        )
+
+    def test_handles_empty_message(self):
+        """
+        Tests that the AppLogger handles an empty log message correctly.
+
+        :return:
+        :rtype:
+        """
+
+        logger = logging.getLogger("test_logger")
+        app_logger = AppLogger(logger, "PREFIX")
+
+        with self.assertLogs("test_logger", level="INFO") as log:
+            app_logger.info("")
+
+        self.assertIn("[PREFIX] ", log.output[0])