Update tests

Author: ahmedxgouda

backend/apps/nest/schedulers/calendar_events/base.py

@@ -1,8 +1,8 @@
 """Base Scheduler for Nest Calendar Events."""
 
+from django.utils import timezone
 from django_rq import get_scheduler
 
-from django.utils import timezone
 from apps.nest.models.reminder_schedule import ReminderSchedule
 
 

backend/tests/apps/nest/schedulers/calendar_events/base_test.py

@@ -3,6 +3,7 @@
 from unittest.mock import MagicMock, patch
 
 import pytest
+from django.utils import timezone
 
 from apps.nest.schedulers.calendar_events.base import BaseScheduler
 
@@ -28,7 +29,7 @@ def test_schedule_once(self, mock_get_scheduler):
         """Test scheduling a one-time reminder."""
         mock_reminder_schedule = MagicMock()
         mock_reminder_schedule.recurrence = "once"
-        mock_reminder_schedule.scheduled_time = "2024-10-10 10:00:00"
+        mock_reminder_schedule.scheduled_time = timezone.datetime(2024, 10, 10, 10, 0, 0)
         mock_reminder_schedule.reminder.message = "Test Message"
         mock_reminder_schedule.reminder.channel_id = "C123456"
 
@@ -38,12 +39,17 @@ def test_schedule_once(self, mock_get_scheduler):
         base_scheduler = BaseScheduler(reminder_schedule=mock_reminder_schedule)
         base_scheduler.schedule()
 
-        scheduler_instance.enqueue_at.assert_called_once_with(
-            "2024-10-10 10:00:00",
+        scheduler_instance.enqueue_at.assert_any_call(
+            mock_reminder_schedule.scheduled_time,
             BaseScheduler.send_message,
             message="Test Message",
             channel_id="C123456",
         )
+        scheduler_instance.enqueue_at.assert_any_call(
+            mock_reminder_schedule.scheduled_time + timezone.timedelta(minutes=1),
+            mock_reminder_schedule.reminder.delete,
+        )
+        mock_reminder_schedule.save.assert_called_once_with(update_fields=["job_id"])
 
     @patch("apps.nest.schedulers.calendar_events.base.get_scheduler")
     def test_schedule_recurring(self, mock_get_scheduler):
@@ -62,12 +68,13 @@ def test_schedule_recurring(self, mock_get_scheduler):
 
         scheduler_instance.cron.assert_called_once_with(
             "0 9 * * *",
-            func=BaseScheduler.send_message,
-            args=("Daily Reminder", "C123456"),
+            func=BaseScheduler.send_message_and_update,
+            args=("Daily Reminder", "C123456", mock_reminder_schedule),
             queue_name="default",
             use_local_timezone=True,
             result_ttl=500,
         )
+        mock_reminder_schedule.save.assert_called_once_with(update_fields=["job_id"])
 
     @patch("apps.nest.schedulers.calendar_events.base.get_scheduler")
     def test_cancel(self, mock_get_scheduler):
@@ -83,10 +90,16 @@ def test_cancel(self, mock_get_scheduler):
         base_scheduler.cancel()
 
         scheduler_instance.cancel.assert_called_once_with("job_123")
-        mock_reminder_schedule.delete.assert_called_once()
+        mock_reminder_schedule.reminder.delete.assert_called_once()
 
     def test_send_message_not_implemented(self):
         """Test that send_message raises NotImplementedError."""
         with pytest.raises(NotImplementedError) as exc_info:
             BaseScheduler.send_message("Test Message", "C123456")
         assert str(exc_info.value) == "Subclasses must implement this method."
+
+    def test_send_message_and_update_not_implemented(self):
+        """Test that send_message_and_update raises NotImplementedError."""
+        with pytest.raises(NotImplementedError) as exc_info:
+            BaseScheduler.send_message_and_update("Test Message", "C123456", MagicMock())
+        assert str(exc_info.value) == "Subclasses must implement this method."

backend/tests/apps/nest/schedulers/calendar_events/slack_test.py

@@ -19,3 +19,13 @@ def test_send_message(self, mock_slack_config):
             channel="C123456",
             text="Test Message",
         )
+
+    @patch("apps.nest.schedulers.calendar_events.slack.SlackScheduler.send_message")
+    @patch("apps.nest.schedulers.calendar_events.slack.update_reminder_schedule_date")
+    def test_send_message_and_update(self, mock_update_reminder_schedule_date, mock_send_message):
+        """Test sending a message and updating it via Slack."""
+        mock_reminder_schedule = MagicMock()
+        SlackScheduler.send_message_and_update("Test Message", "C123456", mock_reminder_schedule)
+
+        mock_send_message.assert_called_once_with("Test Message", "C123456")
+        mock_update_reminder_schedule_date.assert_called_once_with(mock_reminder_schedule)

backend/tests/apps/nest/utils/calendar_events_test.py

@@ -1,6 +1,12 @@
 """Test cases for Nest calendar events utilities."""
 
-from apps.nest.utils.calendar_events import parse_reminder_args
+from unittest.mock import patch
+
+from dateutil.relativedelta import relativedelta
+from django.utils import timezone
+
+from apps.nest.models.reminder_schedule import ReminderSchedule
+from apps.nest.utils.calendar_events import parse_reminder_args, update_reminder_schedule_date
 
 
 class TestCalendarEventsUtils:
@@ -28,3 +34,48 @@ def test_parse_reminder_args_missing_optional_args(self):
         assert args.minutes_before == 10  # Default value
         assert args.message == []  # Default value
         assert args.recurrence == "once"  # Default value
+
+    def test_update_reminder_schedule_date_once(self):
+        """Test update_reminder_schedule_date with 'once' recurrence (no update)."""
+        reminder = ReminderSchedule(scheduled_time=timezone.now(), recurrence="once")
+        original_time = reminder.scheduled_time
+        update_reminder_schedule_date(reminder)
+        assert reminder.scheduled_time == original_time  # No change expected
+
+    def test_update_reminder_schedule_date_future_date(self):
+        """Test update_reminder_schedule_date with a future scheduled_time (no update)."""
+        future_time = timezone.now() + timezone.timedelta(days=1)
+        reminder = ReminderSchedule(scheduled_time=future_time, recurrence="daily")
+        original_time = reminder.scheduled_time
+        update_reminder_schedule_date(reminder)
+        assert reminder.scheduled_time == original_time  # No change expected
+
+    @patch("apps.nest.models.reminder_schedule.ReminderSchedule.save")
+    def test_update_reminder_schedule_date_daily(self, mock_save):
+        """Test update_reminder_schedule_date with 'daily' recurrence."""
+        past_time = timezone.now() - timezone.timedelta(days=1)
+        reminder = ReminderSchedule(scheduled_time=past_time, recurrence="daily")
+        update_reminder_schedule_date(reminder)
+        expected_time = past_time + timezone.timedelta(days=1)
+        assert reminder.scheduled_time == expected_time
+        mock_save.assert_called_once_with(update_fields=["scheduled_time"])
+
+    @patch("apps.nest.models.reminder_schedule.ReminderSchedule.save")
+    def test_update_reminder_schedule_date_weekly(self, mock_save):
+        """Test update_reminder_schedule_date with 'weekly' recurrence."""
+        past_time = timezone.now() - timezone.timedelta(weeks=1)
+        reminder = ReminderSchedule(scheduled_time=past_time, recurrence="weekly")
+        update_reminder_schedule_date(reminder)
+        expected_time = past_time + timezone.timedelta(weeks=1)
+        assert reminder.scheduled_time == expected_time
+        mock_save.assert_called_once_with(update_fields=["scheduled_time"])
+
+    @patch("apps.nest.models.reminder_schedule.ReminderSchedule.save")
+    def test_update_reminder_schedule_date_monthly(self, mock_save):
+        """Test update_reminder_schedule_date with 'monthly' recurrence."""
+        past_time = timezone.now() - timezone.timedelta(days=30)
+        reminder = ReminderSchedule(scheduled_time=past_time, recurrence="monthly")
+        update_reminder_schedule_date(reminder)
+        expected_time = past_time + relativedelta(months=1)
+        assert reminder.scheduled_time == expected_time
+        mock_save.assert_called_once_with(update_fields=["scheduled_time"])

backend/tests/apps/slack/commands/set_reminder_test.py

@@ -7,20 +7,20 @@
 
 
 class TestSetReminderCommand:
-    @patch("apps.slack.commands.set_reminder.get_reminder_blocks")
-    def test_render_blocks_valid_args(self, mock_get_reminder_blocks):
+    @patch("apps.slack.commands.set_reminder.get_setting_reminder_blocks")
+    def test_render_blocks_valid_args(self, mock_get_setting_reminder_blocks):
         """Test render_blocks with valid arguments."""
-        mock_get_reminder_blocks.return_value = [markdown("Reminder set!")]
+        mock_get_setting_reminder_blocks.return_value = [markdown("Reminder set!")]
         command = {
             "text": "--channel C123456 --event_number 1 --minutes_before 10",
             "user_id": "U123456",
         }
         set_reminder_cmd = SetReminder()
         blocks = set_reminder_cmd.render_blocks(command)
         assert blocks == [markdown("Reminder set!")]
-        mock_get_reminder_blocks.assert_called_once()
+        mock_get_setting_reminder_blocks.assert_called_once()
 
-    @patch("apps.slack.commands.set_reminder.parse_reminder_args")
+    @patch("apps.nest.utils.calendar_events.parse_reminder_args")
     def test_render_blocks_invalid_args(self, mock_parse_reminder_args):
         """Test render_blocks with invalid arguments."""
         mock_parse_reminder_args.side_effect = SystemExit()

backend/tests/apps/slack/common/handlers/calendar_events_test.py

@@ -11,7 +11,11 @@
 from apps.nest.models.reminder import Reminder
 from apps.nest.models.reminder_schedule import ReminderSchedule
 from apps.owasp.models.event import Event
-from apps.slack.common.handlers.calendar_events import get_blocks, get_reminder_blocks
+from apps.slack.common.handlers.calendar_events import (
+    get_events_blocks,
+    get_reminders_blocks,
+    get_setting_reminder_blocks,
+)
 from apps.slack.common.presentation import EntityPresentation
 from apps.slack.models.member import Member
 
@@ -23,8 +27,10 @@ class TestCalendarEvents:
     @patch("apps.nest.clients.google_calendar.GoogleCalendarClient")
     @patch("apps.nest.models.google_account_authorization.GoogleAccountAuthorization.authorize")
     @patch("apps.owasp.models.event.Event.parse_google_calendar_events")
-    def test_get_blocks(self, mock_parse_events, mock_authorize, mock_google_calendar_client):
-        """Test get_blocks function."""
+    def test_get_events_blocks(
+        self, mock_parse_events, mock_authorize, mock_google_calendar_client
+    ):
+        """Test get_events_blocks function."""
         auth = GoogleAccountAuthorization(
             access_token="test_access_token",  # noqa: S106
             refresh_token="test_refresh_token",  # noqa: S106
@@ -63,7 +69,7 @@ def test_get_blocks(self, mock_parse_events, mock_authorize, mock_google_calenda
                 key="event2",
             ),
         ]
-        blocks = get_blocks(
+        blocks = get_events_blocks(
             "test_slack_user_id", presentation=EntityPresentation(include_pagination=True), page=1
         )
         assert len(blocks) == 4  # 1 header + 2 events + 1 pagination
@@ -76,10 +82,10 @@ def test_get_blocks(self, mock_parse_events, mock_authorize, mock_google_calenda
 
     @override_settings(IS_GOOGLE_AUTH_ENABLED=True, IS_AWS_KMS_ENABLED=True)
     @patch("apps.nest.models.google_account_authorization.GoogleAccountAuthorization.authorize")
-    def test_get_blocks_no_auth(self, mock_authorize):
-        """Test get_blocks function when no authorization."""
+    def test_get_events_blocks_no_auth(self, mock_authorize):
+        """Test get_events_blocks function when no authorization."""
         mock_authorize.return_value = ("http://auth.url", "state123")  # NOSONAR
-        blocks = get_blocks(
+        blocks = get_events_blocks(
             "test_slack_user_id", presentation=EntityPresentation(include_pagination=True), page=1
         )
         assert len(blocks) == 1
@@ -91,15 +97,15 @@ def test_get_blocks_no_auth(self, mock_authorize):
     @override_settings(IS_GOOGLE_AUTH_ENABLED=True, IS_AWS_KMS_ENABLED=True)
     @patch("apps.nest.clients.google_calendar.GoogleCalendarClient")
     @patch("apps.nest.models.google_account_authorization.GoogleAccountAuthorization.authorize")
-    def test_get_blocks_service_error(self, mock_authorize, mock_google_calendar_client):
-        """Test get_blocks function when Google Calendar service error."""
+    def test_get_events_blocks_service_error(self, mock_authorize, mock_google_calendar_client):
+        """Test get_events_blocks function when Google Calendar service error."""
         mock_authorize.return_value = GoogleAccountAuthorization(
             access_token="test_access_token",  # noqa: S106
             refresh_token="test_refresh_token",  # noqa: S106
             expires_at=timezone.now() + timezone.timedelta(hours=1),
         )
         mock_google_calendar_client.side_effect = ServerNotFoundError()
-        blocks = get_blocks(
+        blocks = get_events_blocks(
             "test_slack_user_id", presentation=EntityPresentation(include_pagination=True), page=1
         )
         assert len(blocks) == 1
@@ -108,24 +114,72 @@ def test_get_blocks_service_error(self, mock_authorize, mock_google_calendar_cli
     @override_settings(IS_GOOGLE_AUTH_ENABLED=True, IS_AWS_KMS_ENABLED=True)
     @patch("apps.nest.clients.google_calendar.GoogleCalendarClient")
     @patch("apps.nest.models.google_account_authorization.GoogleAccountAuthorization.authorize")
-    def test_get_blocks_no_events(self, mock_authorize, mock_google_calendar_client):
-        """Test get_blocks function when no events."""
+    def test_get_events_blocks_no_events(self, mock_authorize, mock_google_calendar_client):
+        """Test get_events_blocks function when no events."""
         mock_authorize.return_value = GoogleAccountAuthorization(
             access_token="test_access_token",  # noqa: S106
             refresh_token="test_refresh_token",  # noqa: S106
             expires_at=timezone.now() + timezone.timedelta(hours=1),
         )
         mock_google_calendar_client.return_value.get_events.return_value = []
-        blocks = get_blocks(
+        blocks = get_events_blocks(
             "test_slack_user_id", presentation=EntityPresentation(include_pagination=True), page=1
         )
         assert len(blocks) == 1
         assert "*No upcoming calendar events found.*" in blocks[0]["text"]["text"]
 
+    @patch("apps.nest.models.reminder_schedule.ReminderSchedule.objects.filter")
+    def test_get_reminders_blocks_success(self, mock_filter):
+        """Test get_reminders_blocks function."""
+        mock_filter.return_value.order_by.return_value = [
+            MagicMock(
+                spec=ReminderSchedule,
+                pk=1,
+                reminder=MagicMock(
+                    spec=Reminder,
+                    channel_id="C123456",
+                    message="Test reminder message",
+                ),
+                scheduled_time=timezone.now() + timezone.timedelta(minutes=10),
+                recurrence="once",
+            ),
+            MagicMock(
+                spec=ReminderSchedule,
+                pk=2,
+                reminder=MagicMock(
+                    spec=Reminder,
+                    channel_id="C654321",
+                    message="Another reminder message",
+                ),
+                scheduled_time=timezone.now() + timezone.timedelta(minutes=20),
+                recurrence="daily",
+            ),
+        ]
+        blocks = get_reminders_blocks("test_slack_user_id")
+        assert len(blocks) == 3  # 1 header + 2 reminders
+        assert "*Your upcoming reminders:*" in blocks[0]["text"]["text"]
+        assert "Test reminder message" in blocks[1]["text"]["text"]
+        assert "Another reminder message" in blocks[2]["text"]["text"]
+        mock_filter.assert_called_once_with(reminder__member__slack_user_id="test_slack_user_id")
+        mock_filter.return_value.order_by.assert_called_once_with("scheduled_time")
+
+    @patch("apps.nest.models.reminder_schedule.ReminderSchedule.objects.filter")
+    def test_get_reminders_blocks_no_reminders(self, mock_filter):
+        """Test get_reminders_blocks function when no reminders."""
+        mock_filter.return_value.order_by.return_value = []
+        blocks = get_reminders_blocks("test_slack_user_id")
+        assert len(blocks) == 1
+        assert (
+            "*No reminders found. You can set one with `/set-reminder`*"
+            in blocks[0]["text"]["text"]
+        )
+        mock_filter.assert_called_once_with(reminder__member__slack_user_id="test_slack_user_id")
+        mock_filter.return_value.order_by.assert_called_once_with("scheduled_time")
+
     @patch("apps.nest.controllers.calendar_events.set_reminder")
     @patch("apps.nest.schedulers.calendar_events.slack.SlackScheduler")
-    def test_get_reminder_blocks_success(self, mock_slack_scheduler, mock_set_reminder):
-        """Test get_reminder_blocks function for successful reminder setting."""
+    def test_get_setting_reminder_blocks_success(self, mock_slack_scheduler, mock_set_reminder):
+        """Test get_setting_reminder_blocks function for successful reminder setting."""
         mock_set_reminder.return_value = MagicMock(
             spec=ReminderSchedule,
             reminder=MagicMock(
@@ -145,7 +199,7 @@ def test_get_reminder_blocks_success(self, mock_slack_scheduler, mock_set_remind
             message=["Test", "reminder", "message"],
             recurrence="daily",
         )
-        blocks = get_reminder_blocks(args, "test_slack_user_id")
+        blocks = get_setting_reminder_blocks(args, "test_slack_user_id")
         assert len(blocks) == 1
         assert "*10-minute reminder set for event " in blocks[0]["text"]["text"]
         mock_set_reminder.assert_called_once_with(
@@ -161,8 +215,8 @@ def test_get_reminder_blocks_success(self, mock_slack_scheduler, mock_set_remind
         mock_slack_scheduler.send_message.assert_called_once()
 
     @patch("apps.nest.controllers.calendar_events.set_reminder")
-    def test_get_reminder_blocks_validation_error(self, mock_set_reminder):
-        """Test get_reminder_blocks function when ValidationError is raised."""
+    def test_get_setting_reminder_blocks_validation_error(self, mock_set_reminder):
+        """Test get_setting_reminder_blocks function when ValidationError is raised."""
         mock_set_reminder.side_effect = ValidationError("Invalid event number.")
         args = MagicMock(
             channel="C123456",
@@ -171,13 +225,13 @@ def test_get_reminder_blocks_validation_error(self, mock_set_reminder):
             message=["Test", "reminder", "message"],
             recurrence="daily",
         )
-        blocks = get_reminder_blocks(args, "test_slack_user_id")
+        blocks = get_setting_reminder_blocks(args, "test_slack_user_id")
         assert len(blocks) == 1
         assert "*Invalid event number.*" in blocks[0]["text"]["text"]
 
     @patch("apps.nest.controllers.calendar_events.set_reminder")
-    def test_get_reminder_blocks_service_error(self, mock_set_reminder):
-        """Test get_reminder_blocks function when service error occurs."""
+    def test_get_setting_reminder_blocks_service_error(self, mock_set_reminder):
+        """Test get_setting_reminder_blocks function when service error occurs."""
         mock_set_reminder.side_effect = ServerNotFoundError()
         args = MagicMock(
             channel="C123456",
@@ -186,6 +240,6 @@ def test_get_reminder_blocks_service_error(self, mock_set_reminder):
             message=["Test", "reminder", "message"],
             recurrence="daily",
         )
-        blocks = get_reminder_blocks(args, "test_slack_user_id")
+        blocks = get_setting_reminder_blocks(args, "test_slack_user_id")
         assert len(blocks) == 1
         assert "*Please check your internet connection.*" in blocks[0]["text"]["text"]