fix(#1701): Events page displays year for events scheduled to start or end at a future year (#2500)

* Add Methods To Check If Event Starts And Ends This Year

* Set Up Templates For Querying Start And End Years

Passed variables to the time_tag template [time_tag.html] that checks if an event was scheduled to start or end with the current year.

* Insert New Test Data And Update test_views.py

More events are created to test particular scenarios of events especially events set to start or end at a future year.

* Time Tag Now Shows Year For Events With Details Not Within The Current Year

The time tag now displays the year when an event will occur. This is only for events that have been scheduled to start or end in at a future year. The accompanying functional tests have also been included.

* Move All Test Data To Functional Test

All test data concerning the provision of data to serve the functional tests have been moved to the functional test.
As it improves readability.
All other test data at test_views.py was reset
to accommodate for the reduction in number of test data instances.

* Functional Test For Displaying Year Of Event For Future Events Now Implemented With Unit Tests

* Remove Functional Test For Displaying Year Of Future Event

Since the current CI at the main branch does not support selenium [web driver] operations, the functional test which depends on selenium to run has been removed.

* Handle Case When Call To Next Event Returns None

* Fix Erroneous Addition To Dev Requirements

This error was introduced in 115af08

* Refactor Tests For Relevant Year String Rendering At Events Page

- Updated the test methods `test_scheduled_to_start_this_year_method` and `test_scheduled_to_end_this_year_method` to better reflect event scheduling edge cases.
- Added assertions to verify when events are not scheduled to start or end within the current year.
- Utilize `unittest.mock` to clamp down datetime-sensitive tests.

---------

Co-authored-by: Jacob Coffee <jacob@z7x.org>

Author: alvindera97

events/models.py

@@ -181,6 +181,20 @@ def next_time(self):
         except IndexError:
             return None
 
+    def is_scheduled_to_start_this_year(self) -> bool:
+        if self.next_time:
+            current_year: int = timezone.now().year
+            if self.next_time.dt_start.year == current_year:
+                return True
+        return False
+
+    def is_scheduled_to_end_this_year(self) -> bool:
+        if self.next_time:
+            current_year: int = timezone.now().year
+            if self.next_time.dt_end.year == current_year:
+                return True
+        return False
+
     @property
     def previous_time(self):
         now = timezone.now()

events/tests/test_models.py

@@ -1,4 +1,6 @@
 import datetime
+from types import SimpleNamespace
+from unittest.mock import patch
 
 from django.contrib.auth import get_user_model
 from django.test import TestCase
@@ -62,7 +64,6 @@ def test_recurring_event(self):
         self.assertEqual(self.event.next_time.dt_start, recurring_time_dtstart)
         self.assertTrue(rt.valid_dt_end())
 
-
         rt.begin = now - datetime.timedelta(days=5)
         rt.finish = now - datetime.timedelta(days=3)
         rt.save()
@@ -186,3 +187,61 @@ def test_event_previous_event(self):
         # 'Event.previous_event' can return None if there is no
         # OccurringRule or RecurringRule found.
         self.assertIsNone(self.event.previous_event)
+
+    def test_scheduled_to_start_this_year_method(self):
+        test_datetime = SimpleNamespace(
+            now=lambda: timezone.datetime(timezone.now().year,
+                                          6, 1, tzinfo=timezone.now().tzinfo)
+        )
+
+        with patch("django.utils.timezone", new=test_datetime) as mock_timezone:
+            with patch("events.models.timezone", new=test_datetime):
+                now = seconds_resolution(mock_timezone.now())
+
+                occurring_time_dtstart = now + datetime.timedelta(days=1)
+                OccurringRule.objects.create(
+                    event=self.event,
+                    dt_start=occurring_time_dtstart,
+                    dt_end=occurring_time_dtstart + datetime.timedelta(days=3)
+                )
+                self.assertTrue(self.event.is_scheduled_to_start_this_year())
+
+                OccurringRule.objects.get(event=self.event).delete()
+
+                event_not_scheduled_to_start_this_year_occurring_time_dtstart = now + datetime.timedelta(days=365)
+                OccurringRule.objects.create(
+                    event=self.event,
+                    dt_start=event_not_scheduled_to_start_this_year_occurring_time_dtstart,
+                    dt_end=event_not_scheduled_to_start_this_year_occurring_time_dtstart + datetime.timedelta(days=3)
+                )
+
+                self.assertFalse(self.event.is_scheduled_to_start_this_year())
+
+    def test_scheduled_to_end_this_year_method(self):
+        test_datetime = SimpleNamespace(
+            now=lambda: timezone.datetime(timezone.now().year,
+                                          6, 1, tzinfo=timezone.now().tzinfo)
+        )
+
+        with patch("django.utils.timezone", new=test_datetime) as mock_timezone:
+            with patch("events.models.timezone", new=test_datetime):
+                now = seconds_resolution(mock_timezone.now())
+                occurring_time_dtstart = now + datetime.timedelta(days=1)
+
+                OccurringRule.objects.create(
+                    event=self.event,
+                    dt_start=occurring_time_dtstart,
+                    dt_end=occurring_time_dtstart
+                )
+
+                self.assertTrue(self.event.is_scheduled_to_end_this_year())
+
+                OccurringRule.objects.get(event=self.event).delete()
+
+                OccurringRule.objects.create(
+                    event=self.event,
+                    dt_start=now,
+                    dt_end=now + datetime.timedelta(days=365)
+                )
+
+                self.assertFalse(self.event.is_scheduled_to_end_this_year())

events/tests/test_views.py

@@ -6,7 +6,7 @@
 from django.test import TestCase
 from django.utils import timezone
 
-from ..models import Calendar, Event, EventCategory, EventLocation, RecurringRule
+from ..models import Calendar, Event, EventCategory, EventLocation, RecurringRule, OccurringRule
 from ..templatetags.events import get_events_upcoming
 from users.factories import UserFactory
 
@@ -18,6 +18,11 @@ def setUpTestData(cls):
         cls.calendar = Calendar.objects.create(creator=cls.user, slug="test-calendar")
         cls.event = Event.objects.create(creator=cls.user, calendar=cls.calendar)
         cls.event_past = Event.objects.create(title='Past Event', creator=cls.user, calendar=cls.calendar)
+        cls.event_single_day = Event.objects.create(title="Single Day Event", creator=cls.user, calendar=cls.calendar)
+        cls.event_starts_at_future_year = Event.objects.create(title='Event Starting Following Year',
+                                                               creator=cls.user, calendar=cls.calendar)
+        cls.event_ends_at_future_year = Event.objects.create(title='Event Ending Following Year',
+                                                             creator=cls.user, calendar=cls.calendar)
 
         cls.now = timezone.now()
 
@@ -34,7 +39,6 @@ def setUpTestData(cls):
             begin=cls.now - datetime.timedelta(days=2),
             finish=cls.now - datetime.timedelta(days=1),
         )
-
         # Future event
         cls.future_event = Event.objects.create(title='Future Event', creator=cls.user, calendar=cls.calendar, featured=True)
         RecurringRule.objects.create(
@@ -67,18 +71,36 @@ def setUpTestData(cls):
             finish=cls.now - datetime.timedelta(days=1),
         )
 
+        cls.rule_single_day = OccurringRule.objects.create(
+            event=cls.event_single_day,
+            dt_start=recurring_time_dtstart,
+            dt_end=recurring_time_dtstart
+        )
+        cls.rule_future_start_year = OccurringRule.objects.create(
+            event=cls.event_starts_at_future_year,
+            dt_start=recurring_time_dtstart + datetime.timedelta(weeks=52),
+            dt_end=recurring_time_dtstart + datetime.timedelta(weeks=53),
+        )
+        cls.rule_future_end_year = OccurringRule.objects.create(
+            event=cls.event_ends_at_future_year,
+            dt_start=recurring_time_dtstart,
+            dt_end=recurring_time_dtend + datetime.timedelta(weeks=52)
+        )
+
     def test_events_homepage(self):
         url = reverse('events:events')
         response = self.client.get(url)
         events = response.context['object_list']
         event_titles = [event.title for event in events]
 
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(len(events), 6)
+        self.assertEqual(len(events), 9)
 
         self.assertIn('Future Event', event_titles)
         self.assertIn('Current Event', event_titles)
         self.assertIn('Past Event', event_titles)
+        self.assertIn('Event Starting Following Year', event_titles)
+        self.assertIn('Event Ending Following Year', event_titles)
 
     def test_calendar_list(self):
         calendars_count = Calendar.objects.count()
@@ -93,7 +115,7 @@ def test_event_list(self):
         response = self.client.get(url)
 
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(len(response.context['object_list']), 3)
+        self.assertEqual(len(response.context['object_list']), 6)
 
         url = reverse('events:event_list_past', kwargs={"calendar_slug": 'unexisting'})
         response = self.client.get(url)
@@ -189,12 +211,21 @@ def test_event_detail(self):
         self.assertEqual(self.event, response.context['object'])
 
     def test_upcoming_tag(self):
-        self.assertEqual(len(get_events_upcoming()), 3)
+        self.assertEqual(len(get_events_upcoming()), 5)
         self.assertEqual(len(get_events_upcoming(only_featured=True)), 1)
         self.rule.begin = self.now - datetime.timedelta(days=3)
         self.rule.finish = self.now - datetime.timedelta(days=2)
         self.rule.save()
-        self.assertEqual(len(get_events_upcoming()), 2)
+        self.assertEqual(len(get_events_upcoming()), 5)
+
+    def test_event_starting_future_year_displays_relevant_year(self):
+        event = self.event_starts_at_future_year
+        url = reverse('events:events')
+        response = self.client.get(url)
+        self.assertIn(
+            f'<span id="start-{event.id}">',
+            response.content.decode()
+        )
 
     def test_context_data(self):
         url = reverse("events:events")
@@ -204,6 +235,23 @@ def test_context_data(self):
         self.assertIn("upcoming_events", response.context)
         self.assertIn("events_now", response.context)
 
+    def test_event_ending_future_year_displays_relevant_year(self):
+        event = self.event_ends_at_future_year
+        url = reverse('events:events')
+        response = self.client.get(url)
+        self.assertIn(
+            f'<span id="end-{event.id}">',
+            response.content.decode()
+        )
+
+    def test_events_scheduled_current_year_does_not_display_current_year(self):
+        event = self.event_single_day
+        url = reverse('events:events')
+        response = self.client.get(url)
+        self.assertIn(  # start date
+            f'<span id="start-{event.id}" class="say-no-more">',
+            response.content.decode()
+        )
 
 class EventSubmitTests(TestCase):
     event_submit_url = reverse_lazy('events:event_submit')

templates/events/event_list.html

@@ -73,7 +73,11 @@ <h3 class="event-title"><a href="{{ object.get_absolute_url }}">{{ object.title|
                         </h3>
                         <p>
                             {% with object.next_time as next_time %}
-                                {% include "events/includes/time_tag.html" %}
+                                {% with object.is_scheduled_to_start_this_year as scheduled_start_this_year %}
+                                    {% with object.is_scheduled_to_end_this_year as scheduled_end_this_year %}
+                                        {% include "events/includes/time_tag.html" %}
+                                    {% endwith %}
+                                {% endwith %}
                             {% endwith %}
 
                             {% if object.venue %}
@@ -98,7 +102,11 @@ <h3 class="event-title"><a
                                     href="{{ object.get_absolute_url }}">{{ object.title|striptags }}</a></h3>
                             <p>
                                 {% with object.previous_time as next_time %}
-                                    {% include "events/includes/time_tag.html" %}
+                                    {% with object.is_scheduled_to_start_this_year as scheduled_start_this_year %}
+                                        {% with object.is_scheduled_to_end_this_year as scheduled_end_this_year %}
+                                            {% include "events/includes/time_tag.html" %}
+                                        {% endwith %}
+                                    {% endwith %}
                                 {% endwith %}
 
                                 {% if object.venue %}

templates/events/includes/time_tag.html

@@ -1,5 +1,32 @@
 {% if next_time.single_day %}
-<time datetime="{{ next_time.dt_start|date:'c' }}">{{ next_time.dt_start|date:"d N" }}<span class="say-no-more"> {{ next_time.dt_start|date:"Y" }}</span>{% if not next_time.all_day %} {{ next_time.dt_start|date:"fA"|lower }} {{ next_time.dt_start|date:"e" }}{% if next_time.valid_dt_end %} – {{ next_time.dt_end|date:"fA"|lower }} {{ next_time.dt_end|date:"e" }}{% endif %}{% endif %}</time>
+    <time datetime="{{ next_time.dt_start|date:'c' }}">{{ next_time.dt_start|date:"d N" }}
+        <span id="start-{{ object.id }}"{% if scheduled_start_this_year %} class="say-no-more"{% endif %}>
+            {{ next_time.dt_start|date:"Y" }}
+        </span>
+
+        <span id="start-{{ object.id }}"{% if scheduled_end_this_year %} class="say-no-more"{% endif %}>
+            {{ next_time.dt_start|date:"Y" }}
+        </span>
+
+        {% if not next_time.all_day %}
+            {{ next_time.dt_start|date:"fA"|lower }} {{ next_time.dt_start|date:"e" }}
+                {% if next_time.valid_dt_end %} – {{ next_time.dt_end|date:"fA"|lower }}
+                    {{ next_time.dt_end|date:"e" }}
+                {% endif %}
+        {% endif %}
+    </time>
 {% else %}
-<time datetime="{{ next_time.dt_start|date:'c' }}">{{ next_time.dt_start|date:"d N" }}{% if next_time.valid_dt_end %} &ndash; {{ next_time.dt_end|date:"d N" }}{% endif %} <span class="say-no-more"> {{ next_time.dt_end|date:"Y" }}</span></time>
+    <time datetime="{{ next_time.dt_start|date:'c' }}">{{ next_time.dt_start|date:"d N" }}
+        <span id="start-{{ object.id }}"{% if scheduled_start_this_year %} class="say-no-more"{% endif %}>
+            {{ next_time.dt_start|date:"Y" }}
+        </span>
+
+        {% if next_time.valid_dt_end %} &ndash;
+            {{ next_time.dt_end|date:"d N" }}
+        {% endif %}
+
+        <span id="end-{{ object.id }}"{% if scheduled_end_this_year %} class="say-no-more"{% endif %}>
+            {{ next_time.dt_end|date:"Y" }}
+        </span>
+    </time>
 {% endif %}