Improves test coverage

Author: sdispater

.coveragerc

@@ -1,2 +1,6 @@
 [run]
-omit = pendulum/lang/*,pendulum/_compat.py,pendulum/version.py
+omit = pendulum/lang/*,
+    pendulum/_compat.py,
+    pendulum/version.py,
+    pendulum/_extensions/*,
+    pendulum/formatting/formatter.py

pendulum/formatting/alternative_formatter.py

@@ -168,8 +168,6 @@ def _format_token(self, dt, token, locale):
 
             return '{}{:02d}{}{:02d}'.format(sign, hour, separator, minute)
 
-        return token
-
     def _format_localizable_token(self, dt, token, locale):
         """
         Formats a Pendulum instance
@@ -186,6 +184,9 @@ def _format_localizable_token(self, dt, token, locale):
 
         :rtype: str
         """
+        trans_id = ''
+        count = 0
+
         if token == 'MMM':
             count = dt.month
             trans_id = 'months_abbrev'
@@ -219,8 +220,6 @@ def _format_localizable_token(self, dt, token, locale):
         elif token == 'A':
             count = (dt.hour, dt.minute)
             trans_id = 'meridian'
-        else:
-            return token
 
         trans = dt.translator().transchoice(trans_id, count, locale=locale)
 

pendulum/pendulum.py

@@ -131,9 +131,6 @@ def _timezone(cls, zone):
         if isinstance(zone, Timezone):
             return zone
 
-        if isinstance(zone, TimezoneInfo):
-            return zone.tz
-
         return Timezone.load(zone)
 
     def __new__(cls, year, month, day,
@@ -217,8 +214,6 @@ def instance(cls, dt, tz=UTC):
                 # the timezone name, we fallback
                 # on a fixed offset
                 offset = dt.utcoffset()
-                if not offset:
-                    raise ValueError('Unsupported tzinfo [{}]'.format(tz))
 
                 tz = dt.utcoffset().total_seconds() / 3600
 
@@ -249,13 +244,8 @@ def parse(cls, time=None, tz=UTC):
 
         dt = dateparser.parse(time)
 
-        if not dt:
-            raise PendulumException('Invalid time string "{}"'.format(time))
-
         if dt.tzinfo:
-            offset = dt.tzinfo.utcoffset(dt)
-            if not offset:
-                offset = datetime.timedelta()
+            offset = dt.utcoffset()
 
             tz = offset.total_seconds() / 3600
 
@@ -941,6 +931,9 @@ def set_formatter(cls, formatter=None):
         if formatter is None:
             formatter = cls._DEFAULT_FORMATTER
 
+        if formatter not in FORMATTERS:
+            raise ValueError('Invalid formatter [{}]'.format(formatter))
+
         cls._FORMATTER = formatter
 
     @classmethod
@@ -1836,7 +1829,7 @@ def first_of(self, unit, day_of_week=None):
         :rtype: Pendulum
         """
         if unit not in ['month', 'quarter', 'year']:
-            raise PendulumException('Invalid unit "{}" for first_of()'.format(unit))
+            raise ValueError('Invalid unit "{}" for first_of()'.format(unit))
 
         return getattr(self, '_first_of_{}'.format(unit))(day_of_week)
 
@@ -1857,7 +1850,7 @@ def last_of(self, unit, day_of_week=None):
         :rtype: Pendulum
         """
         if unit not in ['month', 'quarter', 'year']:
-            raise PendulumException('Invalid unit "{}" for first_of()'.format(unit))
+            raise ValueError('Invalid unit "{}" for first_of()'.format(unit))
 
         return getattr(self, '_last_of_{}'.format(unit))(day_of_week)
 
@@ -1881,7 +1874,7 @@ def nth_of(self, unit, nth, day_of_week):
         :rtype: Pendulum
         """
         if unit not in ['month', 'quarter', 'year']:
-            raise PendulumException('Invalid unit "{}" for first_of()'.format(unit))
+            raise ValueError('Invalid unit "{}" for first_of()'.format(unit))
 
         dt = getattr(self, '_nth_of_{}'.format(unit))(nth, day_of_week)
         if dt is False:
@@ -2151,15 +2144,10 @@ def __rsub__(self, other):
         return self.diff(self._get_datetime(other, True), False)
 
     def __add__(self, other):
-        if isinstance(other, datetime.timedelta):
-            return self.add_timedelta(other)
-
-        result = self._datetime + other
+        if not isinstance(other, datetime.timedelta):
+            return NotImplemented
 
-        if isinstance(result, datetime.datetime):
-            return Pendulum.instance(result)
-
-        return result
+        return self.add_timedelta(other)
 
     def __radd__(self, other):
         return self.__add__(other)
@@ -2236,23 +2224,9 @@ def _getstate(self):
         return (
             self.year, self.month, self.day,
             self.hour, self.minute, self.second, self.microsecond,
-            self.timezone
+            self.timezone_name
         )
 
-    def __setstate__(self, year, month, day, hour, minute, second, microsecond, tz):
-        self._year = year
-        self._month = year
-        self._day = year
-        self._hour = year
-        self._minute = year
-        self._second = year
-        self._datetime = tz.convert(datetime.datetime(
-            year, month, day,
-            hour, minute, second, microsecond
-        ))
-        self._tz = tz
-        self._tzinfo = self._datetime.tzinfo
-
     def __reduce__(self):
         return self.__class__, self._getstate()
 

pendulum/tz/timezone.py

@@ -323,7 +323,6 @@ def _find_utc_index(self, dt):
     def __repr__(self):
         return '<Timezone [{}]>'.format(self._name)
 
-
 class FixedTimezone(Timezone):
     """
     A timezone that has a fixed offset to UTC.

pendulum/tz/transition.py

@@ -64,46 +64,9 @@ def pre_time(self):
     def time(self):
         return self._time
 
-    def __eq__(self, other):
-        own, other = self._get_comparables(other)
-
-        return own == other
-
-    def __ne__(self, other):
-        own, other = self._get_comparables(other)
-
-        return own != other
-
-    def __lt__(self, other):
-        own, other = self._get_comparables(other)
-
-        return own < other
-
-    def __le__(self, other):
-        own, other = self._get_comparables(other)
-
-        return own <= other
-
-    def __gt__(self, other):
-        own, other = self._get_comparables(other)
-
-        return own > other
-
-    def __ge__(self, other):
-        own, other = self._get_comparables(other)
-
-        return own >= other
-
-    def _get_comparables(self, other):
-        if isinstance(other, Transition):
-            own = self._unix_time
-            other = other._unix_time
-        elif isinstance(other, datetime):
-            own = self._time
-        else:
-            own = self._unix_time
-
-        return own, other
+    @property
+    def utc_time(self):
+        return self._utc_time
 
     def __repr__(self):
         return '<Transition [{} UTC, {} -> {}]>'.format(

tests/formatting_tests/classic_formatter_test.py

@@ -2,11 +2,24 @@
 
 from pendulum import Pendulum
 from pendulum.formatting.alternative_formatter import AlternativeFormatter
+from pendulum.lang import TRANSLATIONS
 from .. import AbstractTestCase
 
 
 class ClassicFormatterTest(AbstractTestCase):
 
+    def setUp(self):
+        super(ClassicFormatterTest, self).setUp()
+
+        # Add dummy locale for testing purposes
+        TRANSLATIONS['dummy'] = {}
+
+    def tearDown(self):
+        super(ClassicFormatterTest, self).tearDown()
+
+        # Add dummy locale for testing purposes
+        del TRANSLATIONS['dummy']
+
     def test_year_tokens(self):
         d = Pendulum(2009, 1, 14, 15, 25, 50, 123456)
         f = AlternativeFormatter()
@@ -69,6 +82,12 @@ def test_day_of_year(self):
         self.assertEqual('241e', f.format(d, 'DDDo', locale='fr'))
         self.assertEqual('244e', f.format(d.add(days=3), 'DDDo', locale='fr'))
 
+    def test_week_of_year(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 8, 28)
+
+        self.assertEqual('34th', f.format(d, 'wo'))
+
     def test_day_of_week(self):
         f = AlternativeFormatter()
         d = Pendulum(2016, 8, 28)
@@ -82,6 +101,8 @@ def test_day_of_week(self):
         self.assertEqual('dim', f.format(d, 'ddd', locale='fr'))
         self.assertEqual('dimanche', f.format(d, 'dddd', locale='fr'))
 
+        self.assertEqual('0th', f.format(d, 'do'))
+
     def test_am_pm(self):
         f = AlternativeFormatter()
         d = Pendulum(2016, 8, 28, 23)
@@ -156,6 +177,10 @@ def test_timezone_offset(self):
         self.assertEqual('+0100', f.format(d, 'Z'))
         self.assertEqual('+01:00', f.format(d, 'ZZ'))
 
+        d = Pendulum(2016, 1, 28, 7, 3, 6, 123456, 'America/Guayaquil')
+        self.assertEqual('-0500', f.format(d, 'Z'))
+        self.assertEqual('-05:00', f.format(d, 'ZZ'))
+
     def test_timestamp(self):
         f = AlternativeFormatter()
         d = Pendulum(1970, 1, 1)
@@ -184,3 +209,20 @@ def test_escape(self):
         d = Pendulum(2016, 8, 28)
         self.assertEqual('YYYY 2016 [2016]', f.format(d, '[YYYY] YYYY \[YYYY\]'))
         self.assertEqual('D 28 \\28', f.format(d, '\D D \\\D'))
+
+    def test_date_formats_missing(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 8, 28, 7, 3, 6, 123456)
+
+        self.assertEqual('7:03 AM', f.format(d, 'LT', locale='dummy'))
+        self.assertEqual('7:03:06 AM', f.format(d, 'LTS', locale='dummy'))
+        self.assertEqual('08/28/2016', f.format(d, 'L', locale='dummy'))
+        self.assertEqual('August 28, 2016', f.format(d, 'LL', locale='dummy'))
+        self.assertEqual('August 28, 2016 7:03 AM', f.format(d, 'LLL', locale='dummy'))
+        self.assertEqual('Sunday, August 28, 2016 7:03 AM', f.format(d, 'LLLL', locale='dummy'))
+
+    def test_unknown_token(self):
+        f = AlternativeFormatter()
+        d = Pendulum(2016, 8, 28, 7, 3, 6, 123456)
+
+        self.assertEqual('J', f.format(d, 'J'))

tests/formatting_tests/test_alternative_formatter.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+
+import re
+from pendulum import Pendulum
+from pendulum.formatting.classic_formatter import ClassicFormatter
+from .. import AbstractTestCase
+
+
+class ClassicFormatterTest(AbstractTestCase):
+
+    def test_custom_formatters(self):
+        d = Pendulum(1975, 12, 25, 14, 15, 16, tzinfo='local')
+        f = ClassicFormatter()
+        self.assertEqual(
+            'Thursday 25th of December 1975 02:15:16 PM -05:00',
+            f.format(d, '%A %-d%_t of %B %Y %I:%M:%S %p %_z')
+        )
+
+    def test_format_with_locale(self):
+        d = Pendulum(1975, 12, 25, 14, 15, 16, tzinfo='Europe/Paris')
+        f = ClassicFormatter()
+        self.assertEqual(
+            'jeudi 25e jour de décembre 1975 02:15:16  +01:00',
+            f.format(d, '%A %-d%_t jour de %B %Y %I:%M:%S %p %_z', locale='fr')
+        )
+
+    def test_unlocalizable_directive(self):
+        d = Pendulum(1975, 12, 25, 14, 15, 16, tzinfo='local')
+        f = ClassicFormatter()
+        self.assertRaises(ValueError, f._localize_directive, d, '%8', 'en')
+
+    def test_day_of_week(self):
+        f = ClassicFormatter()
+        d = Pendulum(2016, 8, 28)
+
+        self.assertEqual('Sun', f.format(d, '%a'))
+        self.assertEqual('Sunday', f.format(d, '%A'))
+
+        self.assertEqual('dim', f.format(d, '%a', locale='fr'))
+        self.assertEqual('dimanche', f.format(d, '%A', locale='fr'))
+
+    def test_month(self):
+        f = ClassicFormatter()
+        d = Pendulum(2016, 8, 28)
+
+        self.assertEqual('Aug', f.format(d, '%b'))
+        self.assertEqual('August', f.format(d, '%B'))
+
+        self.assertEqual('août', f.format(d, '%b', locale='fr'))
+        self.assertEqual('août', f.format(d, '%B', locale='fr'))
+
+    def test_strftime(self):
+        f = ClassicFormatter()
+        d = Pendulum(2016, 8, 28)
+        m = re.match('(.*)', '%_TTT')
+
+        self.assertRaises(ValueError, f._strftime, d, m, 'fr')

tests/formatting_tests/test_classic_formatter.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+

tests/helpers_tests/__init__.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+from pendulum.helpers import local_time
+from pendulum import Pendulum
+from .. import AbstractTestCase
+
+
+class LocalTimeTest(AbstractTestCase):
+
+    def test_local_time_positive_integer(self):
+        d = Pendulum(2016, 8, 7, 12, 34, 56)
+
+        t = local_time(d.timestamp, 0)
+        self.assertEqual(d.year, t[0])
+        self.assertEqual(d.month, t[1])
+        self.assertEqual(d.day, t[2])
+        self.assertEqual(d.hour, t[3])
+        self.assertEqual(d.minute, t[4])
+        self.assertEqual(d.second, t[5])