Updates localization tests

Author: sdispater

tests/localization_tests/__init__.py

@@ -14,7 +14,8 @@ def tearDown(self):
         Pendulum.set_locale('en')
 
     def test_diff_for_humans_localized(self):
-        self.diff_for_humans()
+        with Pendulum.test(Pendulum(2016, 8, 29)):
+            self.diff_for_humans()
 
     def diff_for_humans(self):
         raise NotImplementedError()

tests/localization_tests/test_da.py

@@ -12,56 +12,55 @@ class DaTest(AbstractLocalizationTestCase, AbstractTestCase):
     locale = 'da'
 
     def diff_for_humans(self):
-        with self.wrap_with_test_now():
-            d = Pendulum.now().subtract(seconds=1)
-            self.assertEqual('1 sekund siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(seconds=1)
+        self.assertEqual('1 sekund siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(seconds=2)
-            self.assertEqual('2 sekunder siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(seconds=2)
+        self.assertEqual('2 sekunder siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(minutes=1)
-            self.assertEqual('1 minut siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(minutes=1)
+        self.assertEqual('1 minut siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(minutes=2)
-            self.assertEqual('2 minutter siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(minutes=2)
+        self.assertEqual('2 minutter siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(hours=1)
-            self.assertEqual('1 time siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(hours=1)
+        self.assertEqual('1 time siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(hours=2)
-            self.assertEqual('2 timer siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(hours=2)
+        self.assertEqual('2 timer siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(days=1)
-            self.assertEqual('1 dag siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(days=1)
+        self.assertEqual('1 dag siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(days=2)
-            self.assertEqual('2 dage siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(days=2)
+        self.assertEqual('2 dage siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(weeks=1)
-            self.assertEqual('1 uge siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(weeks=1)
+        self.assertEqual('1 uge siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(weeks=2)
-            self.assertEqual('2 uger siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(weeks=2)
+        self.assertEqual('2 uger siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(months=1)
-            self.assertEqual('1 måned siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(months=1)
+        self.assertEqual('1 måned siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(months=2)
-            self.assertEqual('2 måneder siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(months=2)
+        self.assertEqual('2 måneder siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(years=1)
-            self.assertEqual('1 år siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(years=1)
+        self.assertEqual('1 år siden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(years=2)
-            self.assertEqual('2 år siden', d.diff_for_humans())
+        d = Pendulum.now().subtract(years=2)
+        self.assertEqual('2 år siden', d.diff_for_humans())
 
-            d = Pendulum.now().add(seconds=1)
-            self.assertEqual('om 1 sekund', d.diff_for_humans())
+        d = Pendulum.now().add(seconds=1)
+        self.assertEqual('om 1 sekund', d.diff_for_humans())
 
-            d = Pendulum.now().add(seconds=1)
-            d2 = Pendulum.now()
-            self.assertEqual('1 sekund efter', d.diff_for_humans(d2))
-            self.assertEqual('1 sekund før', d2.diff_for_humans(d))
+        d = Pendulum.now().add(seconds=1)
+        d2 = Pendulum.now()
+        self.assertEqual('1 sekund efter', d.diff_for_humans(d2))
+        self.assertEqual('1 sekund før', d2.diff_for_humans(d))
 
-            self.assertEqual('1 sekund', d.diff_for_humans(d2, True))
-            self.assertEqual('2 sekunder', d2.diff_for_humans(d.add(seconds=1), True))
+        self.assertEqual('1 sekund', d.diff_for_humans(d2, True))
+        self.assertEqual('2 sekunder', d2.diff_for_humans(d.add(seconds=1), True))

tests/localization_tests/test_de.py

@@ -12,56 +12,55 @@ class DeTest(AbstractLocalizationTestCase, AbstractTestCase):
     locale = 'de'
 
     def diff_for_humans(self):
-        with self.wrap_with_test_now():
-            d = Pendulum.now().subtract(seconds=1)
-            self.assertEqual('vor 1 Sekunde', d.diff_for_humans())
+        d = Pendulum.now().subtract(seconds=1)
+        self.assertEqual('vor 1 Sekunde', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(seconds=2)
-            self.assertEqual('vor 2 Sekunden', d.diff_for_humans())
+        d = Pendulum.now().subtract(seconds=2)
+        self.assertEqual('vor 2 Sekunden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(minutes=1)
-            self.assertEqual('vor 1 Minute', d.diff_for_humans())
+        d = Pendulum.now().subtract(minutes=1)
+        self.assertEqual('vor 1 Minute', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(minutes=2)
-            self.assertEqual('vor 2 Minuten', d.diff_for_humans())
+        d = Pendulum.now().subtract(minutes=2)
+        self.assertEqual('vor 2 Minuten', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(hours=1)
-            self.assertEqual('vor 1 Stunde', d.diff_for_humans())
+        d = Pendulum.now().subtract(hours=1)
+        self.assertEqual('vor 1 Stunde', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(hours=2)
-            self.assertEqual('vor 2 Stunden', d.diff_for_humans())
+        d = Pendulum.now().subtract(hours=2)
+        self.assertEqual('vor 2 Stunden', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(days=1)
-            self.assertEqual('vor 1 Tag', d.diff_for_humans())
+        d = Pendulum.now().subtract(days=1)
+        self.assertEqual('vor 1 Tag', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(days=2)
-            self.assertEqual('vor 2 Tagen', d.diff_for_humans())
+        d = Pendulum.now().subtract(days=2)
+        self.assertEqual('vor 2 Tagen', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(weeks=1)
-            self.assertEqual('vor 1 Woche', d.diff_for_humans())
+        d = Pendulum.now().subtract(weeks=1)
+        self.assertEqual('vor 1 Woche', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(weeks=2)
-            self.assertEqual('vor 2 Wochen', d.diff_for_humans())
+        d = Pendulum.now().subtract(weeks=2)
+        self.assertEqual('vor 2 Wochen', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(months=1)
-            self.assertEqual('vor 1 Monat', d.diff_for_humans())
+        d = Pendulum.now().subtract(months=1)
+        self.assertEqual('vor 1 Monat', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(months=2)
-            self.assertEqual('vor 2 Monaten', d.diff_for_humans())
+        d = Pendulum.now().subtract(months=2)
+        self.assertEqual('vor 2 Monaten', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(years=1)
-            self.assertEqual('vor 1 Jahr', d.diff_for_humans())
+        d = Pendulum.now().subtract(years=1)
+        self.assertEqual('vor 1 Jahr', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(years=2)
-            self.assertEqual('vor 2 Jahren', d.diff_for_humans())
+        d = Pendulum.now().subtract(years=2)
+        self.assertEqual('vor 2 Jahren', d.diff_for_humans())
 
-            d = Pendulum.now().add(seconds=1)
-            self.assertEqual('in 1 Sekunde', d.diff_for_humans())
+        d = Pendulum.now().add(seconds=1)
+        self.assertEqual('in 1 Sekunde', d.diff_for_humans())
 
-            d = Pendulum.now().add(seconds=1)
-            d2 = Pendulum.now()
-            self.assertEqual('1 Sekunde später', d.diff_for_humans(d2))
-            self.assertEqual('1 Sekunde zuvor', d2.diff_for_humans(d))
+        d = Pendulum.now().add(seconds=1)
+        d2 = Pendulum.now()
+        self.assertEqual('1 Sekunde später', d.diff_for_humans(d2))
+        self.assertEqual('1 Sekunde zuvor', d2.diff_for_humans(d))
 
-            self.assertEqual('1 Sekunde', d.diff_for_humans(d2, True))
-            self.assertEqual('2 Sekunden', d2.diff_for_humans(d.add(seconds=1), True))
+        self.assertEqual('1 Sekunde', d.diff_for_humans(d2, True))
+        self.assertEqual('2 Sekunden', d2.diff_for_humans(d.add(seconds=1), True))

tests/localization_tests/test_es.py

@@ -12,56 +12,55 @@ class EsTest(AbstractLocalizationTestCase, AbstractTestCase):
     locale = 'es'
 
     def diff_for_humans(self):
-        with self.wrap_with_test_now():
-            d = Pendulum.now().subtract(seconds=1)
-            self.assertEqual('hace 1 segundo', d.diff_for_humans())
+        d = Pendulum.now().subtract(seconds=1)
+        self.assertEqual('hace 1 segundo', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(seconds=2)
-            self.assertEqual('hace 2 segundos', d.diff_for_humans())
+        d = Pendulum.now().subtract(seconds=2)
+        self.assertEqual('hace 2 segundos', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(minutes=1)
-            self.assertEqual('hace 1 minuto', d.diff_for_humans())
+        d = Pendulum.now().subtract(minutes=1)
+        self.assertEqual('hace 1 minuto', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(minutes=2)
-            self.assertEqual('hace 2 minutos', d.diff_for_humans())
+        d = Pendulum.now().subtract(minutes=2)
+        self.assertEqual('hace 2 minutos', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(hours=1)
-            self.assertEqual('hace 1 hora', d.diff_for_humans())
+        d = Pendulum.now().subtract(hours=1)
+        self.assertEqual('hace 1 hora', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(hours=2)
-            self.assertEqual('hace 2 horas', d.diff_for_humans())
+        d = Pendulum.now().subtract(hours=2)
+        self.assertEqual('hace 2 horas', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(days=1)
-            self.assertEqual('hace 1 día', d.diff_for_humans())
+        d = Pendulum.now().subtract(days=1)
+        self.assertEqual('hace 1 día', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(days=2)
-            self.assertEqual('hace 2 días', d.diff_for_humans())
+        d = Pendulum.now().subtract(days=2)
+        self.assertEqual('hace 2 días', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(weeks=1)
-            self.assertEqual('hace 1 semana', d.diff_for_humans())
+        d = Pendulum.now().subtract(weeks=1)
+        self.assertEqual('hace 1 semana', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(weeks=2)
-            self.assertEqual('hace 2 semanas', d.diff_for_humans())
+        d = Pendulum.now().subtract(weeks=2)
+        self.assertEqual('hace 2 semanas', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(months=1)
-            self.assertEqual('hace 1 mes', d.diff_for_humans())
+        d = Pendulum.now().subtract(months=1)
+        self.assertEqual('hace 1 mes', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(months=2)
-            self.assertEqual('hace 2 meses', d.diff_for_humans())
+        d = Pendulum.now().subtract(months=2)
+        self.assertEqual('hace 2 meses', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(years=1)
-            self.assertEqual('hace 1 año', d.diff_for_humans())
+        d = Pendulum.now().subtract(years=1)
+        self.assertEqual('hace 1 año', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(years=2)
-            self.assertEqual('hace 2 años', d.diff_for_humans())
+        d = Pendulum.now().subtract(years=2)
+        self.assertEqual('hace 2 años', d.diff_for_humans())
 
-            d = Pendulum.now().add(seconds=1)
-            self.assertEqual('dentro de 1 segundo', d.diff_for_humans())
+        d = Pendulum.now().add(seconds=1)
+        self.assertEqual('dentro de 1 segundo', d.diff_for_humans())
 
-            d = Pendulum.now().add(seconds=1)
-            d2 = Pendulum.now()
-            self.assertEqual('1 segundo después', d.diff_for_humans(d2))
-            self.assertEqual('1 segundo antes', d2.diff_for_humans(d))
+        d = Pendulum.now().add(seconds=1)
+        d2 = Pendulum.now()
+        self.assertEqual('1 segundo después', d.diff_for_humans(d2))
+        self.assertEqual('1 segundo antes', d2.diff_for_humans(d))
 
-            self.assertEqual('1 segundo', d.diff_for_humans(d2, True))
-            self.assertEqual('2 segundos', d2.diff_for_humans(d.add(seconds=1), True))
+        self.assertEqual('1 segundo', d.diff_for_humans(d2, True))
+        self.assertEqual('2 segundos', d2.diff_for_humans(d.add(seconds=1), True))

tests/localization_tests/test_fa.py

@@ -12,56 +12,55 @@ class FaTest(AbstractLocalizationTestCase, AbstractTestCase):
     locale = 'fa'
 
     def diff_for_humans(self):
-        with self.wrap_with_test_now():
-            d = Pendulum.now().subtract(seconds=1)
-            self.assertEqual('1 ثانیه پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(seconds=1)
+        self.assertEqual('1 ثانیه پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(seconds=2)
-            self.assertEqual('2 ثانیه پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(seconds=2)
+        self.assertEqual('2 ثانیه پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(minutes=1)
-            self.assertEqual('1 دقیقه پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(minutes=1)
+        self.assertEqual('1 دقیقه پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(minutes=2)
-            self.assertEqual('2 دقیقه پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(minutes=2)
+        self.assertEqual('2 دقیقه پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(hours=1)
-            self.assertEqual('1 ساعت پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(hours=1)
+        self.assertEqual('1 ساعت پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(hours=2)
-            self.assertEqual('2 ساعت پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(hours=2)
+        self.assertEqual('2 ساعت پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(days=1)
-            self.assertEqual('1 روز پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(days=1)
+        self.assertEqual('1 روز پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(days=2)
-            self.assertEqual('2 روز پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(days=2)
+        self.assertEqual('2 روز پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(weeks=1)
-            self.assertEqual('1 هفته پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(weeks=1)
+        self.assertEqual('1 هفته پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(weeks=2)
-            self.assertEqual('2 هفته پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(weeks=2)
+        self.assertEqual('2 هفته پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(months=1)
-            self.assertEqual('1 ماه پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(months=1)
+        self.assertEqual('1 ماه پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(months=2)
-            self.assertEqual('2 ماه پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(months=2)
+        self.assertEqual('2 ماه پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(years=1)
-            self.assertEqual('1 سال پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(years=1)
+        self.assertEqual('1 سال پیش', d.diff_for_humans())
 
-            d = Pendulum.now().subtract(years=2)
-            self.assertEqual('2 سال پیش', d.diff_for_humans())
+        d = Pendulum.now().subtract(years=2)
+        self.assertEqual('2 سال پیش', d.diff_for_humans())
 
-            d = Pendulum.now().add(seconds=1)
-            self.assertEqual('1 ثانیه بعد', d.diff_for_humans())
+        d = Pendulum.now().add(seconds=1)
+        self.assertEqual('1 ثانیه بعد', d.diff_for_humans())
 
-            d = Pendulum.now().add(seconds=1)
-            d2 = Pendulum.now()
-            self.assertEqual('1 ثانیه پس از', d.diff_for_humans(d2))
-            self.assertEqual('1 ثانیه پیش از', d2.diff_for_humans(d))
+        d = Pendulum.now().add(seconds=1)
+        d2 = Pendulum.now()
+        self.assertEqual('1 ثانیه پس از', d.diff_for_humans(d2))
+        self.assertEqual('1 ثانیه پیش از', d2.diff_for_humans(d))
 
-            self.assertEqual('1 ثانیه', d.diff_for_humans(d2, True))
-            self.assertEqual('2 ثانیه', d2.diff_for_humans(d.add(seconds=1), True))
+        self.assertEqual('1 ثانیه', d.diff_for_humans(d2, True))
+        self.assertEqual('2 ثانیه', d2.diff_for_humans(d.add(seconds=1), True))