Extend tests

Author: jvamvas

openinghours/templatetags/openinghours_tags.py

@@ -2,7 +2,7 @@
 from django.template.loader import get_template
 from django.utils.translation import ugettext_lazy as _
 
-from openinghours.models import *
+from openinghours.models import WEEKDAYS, OpeningHours
 from openinghours import utils
 
 
@@ -11,6 +11,9 @@
 
 @register.filter(expects_localtime=True)
 def iso_day_to_weekday(d):
+    """
+    Returns the weekday's name given a ISO weekday number; "today" if today is the same weekday
+    """
     if int(d) == utils.get_now().isoweekday():
         return _("today")
     for w in WEEKDAYS:
@@ -32,6 +35,9 @@ def to_weekday(date_obj_tpl):
 
 @register.assignment_tag
 def is_open(location=None, attr=None):
+    """
+    Returns False if the location is closed, or the OpeningHours object specifying that the location is currently open
+    """
     obj = utils.is_open(location)
     if obj is False:
         return False
@@ -42,6 +48,10 @@ def is_open(location=None, attr=None):
 
 @register.assignment_tag
 def next_time_open(location):
+    """
+    Returns the next possible OpeningHours object, or False if the location is currently open or if there is no such
+    object
+    """
     obj, ts = utils.next_time_open(location)
     return obj
 
@@ -58,7 +68,6 @@ def has_closing_rule_for_now(location, attr=None):
 
 @register.filter(expects_localtime=True)
 def get_closing_rule_for_now(location, attr=None):
-    """Only accesses the *first* closing rule, because closed means closed."""
     obj = utils.get_closing_rule_for_now(location)
     if obj is False:
         return False
@@ -69,7 +78,9 @@ def get_closing_rule_for_now(location, attr=None):
 
 @register.simple_tag
 def opening_hours(location=None, concise=False):
-    """Creates a rendered listing of hours."""
+    """
+    Creates a rendered listing of hours.
+    """
     template_name = 'openinghours/opening_hours_list.html'
     days = []  # [{'hours': '9:00am to 5:00pm', 'name': u'Monday'}, {'hours...
 

openinghours/tests/test_templatetags.py

@@ -1,7 +1,9 @@
 from django.utils.encoding import force_text
 from freezegun import freeze_time
 
-from openinghours.templatetags.openinghours_tags import iso_day_to_weekday
+from openinghours.models import OpeningHours, ClosingRules
+from openinghours.templatetags.openinghours_tags import iso_day_to_weekday, is_open, next_time_open, \
+    has_closing_rule_for_now, get_closing_rule_for_now
 from openinghours.tests.tests import OpeningHoursTestCase
 
 
@@ -22,20 +24,53 @@ def test_iso_day_to_weekday(self):
             self.assertEqual(force_text(iso_day_to_weekday(2)), u'today')
 
     def test_to_weekday(self):
-        pass
+        pass  # TODO: Write test
 
     def test_is_open(self):
-        pass
+        with freeze_time("2016-02-22 09:00:00"):  # Monday
+            self.assertEqual(
+                    is_open(self.company),
+                    OpeningHours.objects.filter(company=self.company).first()
+            )
+        with freeze_time("2016-02-22 12:15:00"):  # Monday
+            self.assertFalse(is_open(self.company))
+        with freeze_time("2016-02-22 23:00:30"):  # Monday
+            self.assertFalse(is_open(self.company))
+        with freeze_time("2016-02-23 17:59:59"):  # Tuesday
+            self.assertTrue(is_open(self.company))
+        with freeze_time("2016-02-23 18:00:00"):  # Tuesday
+            self.assertTrue(is_open(self.company))
+        with freeze_time("2016-02-23 18:00:01"):  # Tuesday
+            self.assertFalse(is_open(self.company))
+        with freeze_time("2016-02-23 18:29:59"):  # Tuesday
+            self.assertFalse(is_open(self.company))
+        with freeze_time("2016-02-23 18:30:00"):  # Tuesday
+            self.assertTrue(is_open(self.company))
 
     def test_next_time_open(self):
-        pass
+        with freeze_time("2016-02-22 08:00:00"):  # Monday
+            self.assertEqual(
+                    next_time_open(self.company),
+                    OpeningHours.objects.filter(company=self.company).first()
+            )
+        with freeze_time("2016-02-22 09:00:00"):  # Monday
+            self.assertFalse(next_time_open(self.company))
 
     def test_has_closing_rule_for_now(self):
-        pass
+        with freeze_time("2015-12-26 10:00:00"):
+            self.assertTrue(has_closing_rule_for_now(self.company))
+        with freeze_time("2016-02-22 10:00:00"):
+            self.assertFalse(has_closing_rule_for_now(self.company))
 
     def test_get_closing_rule_for_now(self):
-        pass
+        with freeze_time("2015-12-26 10:00:00"):
+            self.assertEqual(
+                    get_closing_rule_for_now(self.company).first(),
+                    ClosingRules.objects.filter(company=self.company).first()
+            )
+        with freeze_time("2016-02-22 10:00:00"):
+            self.assertFalse(get_closing_rule_for_now(self.company))
 
     def opening_hours(self):
-        pass
+        pass # TODO: Write test
 

openinghours/tests/tests.py

@@ -22,27 +22,24 @@ def setUp(self):
             6: ['10:00 13:00'],
             7: None,
         }
-        company, created = Company.objects.get_or_create(name="Company Ltd.",
+        self.company, created = Company.objects.get_or_create(name="Company Ltd.",
                                                          slug="company-ltd")
         for day, hours in test_data.items():
             if not hours:
                 continue
             for slot in hours:
                 from_hour, to_hour = slot.split()
                 OpeningHours.objects.get_or_create(
-                    company=company,
+                    company=self.company,
                     weekday=day,
                     from_hour=str_to_time(from_hour),
                     to_hour=str_to_time(to_hour)
                 )
 
-        def days_ahead(d): return datetime.today() + timedelta(days=d)
-
-        # setup some holidays
         holiday = ClosingRules.objects.create(
-            company=company,
-            start=days_ahead(2),
-            end=days_ahead(4),
+            company=self.company,
+            start=datetime(2015, 12, 25) - timedelta(days=2),
+            end=datetime(2015, 12, 25) + timedelta(days=4),
             reason="Public holiday"
         )
 

openinghours/utils.py

@@ -46,7 +46,7 @@ def get_now():
 
 def get_closing_rule_for_now(location):
     """
-    Access all the closing rules for a company
+    Returns QuerySet of ClosingRules that are currently valid
     """
     now = get_now()
 
@@ -105,7 +105,8 @@ def is_open(location, now=None):
 
 def next_time_open(location):
     """
-    Returns the next possible opening hours object.
+    Returns the next possible opening hours object, or (False, None) if location is currently open or there is no
+    such object
     I.e. when is the company open for the next time?
     """
     if not is_open(location):