Fixes __add__, __sub__ and __neg__ for intervals

Author: sdispater

pendulum/pendulum_interval.py

@@ -233,26 +233,22 @@ def __repr__(self):
 
     def __add__(self, other):
         if isinstance(other, timedelta):
-            return PendulumInterval(self._days + other._days,
-                                    self._seconds + other._seconds,
-                                    self._microseconds + other._microseconds)
+            return PendulumInterval(seconds=self.total_seconds() + other.total_seconds())
+
         return NotImplemented
 
     def __sub__(self, other):
         if isinstance(other, timedelta):
             # for CPython compatibility, we cannot use
             # our __class__ here, but need a real timedelta
-            return PendulumInterval(self._days - other._days,
-                                    self._seconds - other._seconds,
-                                    self._microseconds - other._microseconds)
+            return PendulumInterval(seconds=self.total_seconds() - other.total_seconds())
+
         return NotImplemented
 
     def __neg__(self):
         # for CPython compatibility, we cannot use
         # our __class__ here, but need a real timedelta
-        return PendulumInterval(-self._days,
-                                -self._seconds,
-                                -self._microseconds)
+        return PendulumInterval(seconds=-self.total_seconds())
 
 
 class AbsolutePendulumInterval(PendulumInterval):

tests/interval_tests/test_add_sub.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+
+from datetime import timedelta
+from pendulum import PendulumInterval
+
+from .. import AbstractTestCase
+
+
+class AddSubTestCase(AbstractTestCase):
+
+    def test_add_interval(self):
+        p1 = PendulumInterval(days=23, seconds=32)
+        p2 = PendulumInterval(days=12, seconds=30)
+
+        p = p1 + p2
+        self.assertInterval(p, 5, 0, 0, 1, 2)
+
+    def test_add_timedelta(self):
+        p1 = PendulumInterval(days=23, seconds=32)
+        p2 = timedelta(days=12, seconds=30)
+
+        p = p1 + p2
+        self.assertInterval(p, 5, 0, 0, 1, 2)
+
+    def test_add_unsupported(self):
+        p = PendulumInterval(days=23, seconds=32)
+        self.assertEqual(NotImplemented, p.__add__(5))
+
+    def test_sub_interval(self):
+        p1 = PendulumInterval(days=23, seconds=32)
+        p2 = PendulumInterval(days=12, seconds=28)
+
+        p = p1 - p2
+        self.assertInterval(p, 1, 4, 0, 0, 4)
+
+    def test_sub_timedelta(self):
+        p1 = PendulumInterval(days=23, seconds=32)
+        p2 = timedelta(days=12, seconds=28)
+
+        p = p1 - p2
+        self.assertInterval(p, 1, 4, 0, 0, 4)
+
+    def test_sub_unsupported(self):
+        p = PendulumInterval(days=23, seconds=32)
+        self.assertEqual(NotImplemented, p.__sub__(5))
+
+    def test_neg(self):
+        p = PendulumInterval(days=23, seconds=32)
+        self.assertInterval(-p, -4, -5, 0, 0, -28)

tests/interval_tests/test_construct.py

@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
 
+from datetime import timedelta
 from pendulum import PendulumInterval
+from pendulum.pendulum_interval import AbsolutePendulumInterval
 
 from .. import AbstractTestCase
 
@@ -40,3 +42,19 @@ def test_minutes(self):
     def test_all(self):
         pi = PendulumInterval(days=1177, seconds=7284, microseconds=1000000)
         self.assertInterval(pi, 168, 1, 2, 1, 25)
+
+    def test_instance(self):
+        pi = PendulumInterval.instance(timedelta(days=1177, seconds=7284, microseconds=1000000))
+        self.assertInterval(pi, 168, 1, 2, 1, 25)
+
+    def test_absolute_interval(self):
+        pi = AbsolutePendulumInterval(days=-1177, seconds=-7284, microseconds=-1000001)
+        self.assertInterval(pi, 168, 1, 2, 1, 25)
+        self.assertEqual(999999, pi.microseconds)
+
+    def test_invert(self):
+        pi = PendulumInterval(days=1177, seconds=7284, microseconds=1000000)
+        self.assertFalse(pi.invert)
+
+        pi = PendulumInterval(days=-1177, seconds=-7284, microseconds=-1000000)
+        self.assertTrue(pi.invert)

tests/interval_tests/test_in_words.py

@@ -36,3 +36,10 @@ def test_in_french(self):
             '168 semaines 1 jour 2 heures 1 minute 25 secondes',
             pi.in_words(locale='fr')
         )
+
+    def test_repr(self):
+        pi = PendulumInterval(days=1177, seconds=7284, microseconds=1000000)
+        self.assertEqual(
+            '168 weeks 1 day 2 hours 1 minute 25 seconds',
+            repr(pi)
+        )

tests/interval_tests/test_locale.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+from pendulum import PendulumInterval
+from pendulum.translator import Translator
+
+from .. import AbstractTestCase
+
+
+class LocaleTest(AbstractTestCase):
+
+    def test_get_locale(self):
+        pi = PendulumInterval
+        self.assertEqual('en', pi.get_locale())
+
+        pi.set_locale('fr')
+        self.assertEqual('fr', pi.get_locale())
+
+        pi.set_locale('en')
+
+    def test_set_invalid_locale(self):
+        pi = PendulumInterval
+        self.assertFalse(pi.set_locale('invalid'))
+
+    def test_set_translator(self):
+        pi = PendulumInterval
+        t = Translator('en')
+        pi.set_translator(t)
+        self.assertIs(t, pi.translator())
+
+

tests/interval_tests/test_total_methods.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+from pendulum.pendulum_interval import PendulumInterval
+
+from .. import AbstractTestCase
+
+
+class TotalMethodsTest(AbstractTestCase):
+
+    def test_total_years(self):
+        it = PendulumInterval(days=365)
+        self.assertEqual(1, it.total_years())
+
+    def test_in_months(self):
+        it = PendulumInterval(days=75)
+        self.assertEqual(2.5, it.total_months())
+
+    def test_in_weeks(self):
+        it = PendulumInterval(days=17)
+        self.assertEqual(2.43, round(it.total_weeks(), 2))
+
+    def test_in_days(self):
+        it = PendulumInterval(days=3)
+        self.assertEqual(3, it.total_days())
+
+    def test_in_hours(self):
+        it = PendulumInterval(days=3, minutes=72)
+        self.assertEqual(73.2, it.total_hours())
+
+    def test_in_minutes(self):
+        it = PendulumInterval(minutes=6, seconds=72)
+        self.assertEqual(7.2, it.total_minutes())
+
+    def test_in_seconds(self):
+        it = PendulumInterval(seconds=72, microseconds=123456)
+        self.assertEqual(72.123456, it.total_seconds())