Merge pull request #978 from jpurviance/utils-pytest

Migrate away from unittest and adopt pytest

changelog.d/978.misc.rst

@@ -0,0 +1,2 @@
+Move test suite towards pytest and away from unittest.
+Reported and fixed by @jpurviance (gh pr #978)

dateutil/test/test_imports.py

@@ -1,166 +1,176 @@
 import sys
-import unittest
+import pytest
 
-class ImportVersionTest(unittest.TestCase):
+
+HOST_IS_WINDOWS = sys.platform.startswith('win')
+
+
+def test_import_version_str():
     """ Test that dateutil.__version__ can be imported"""
+    from dateutil import __version__
+
+
+def test_import_version_root():
+    import dateutil
+    assert hasattr(dateutil, '__version__')
+
+
+# Test that dateutil.easter-related imports work properly
+def test_import_easter_direct():
+    import dateutil.easter
+
+
+def test_import_easter_from():
+    from dateutil import easter
+
+
+def test_import_easter_start():
+    from dateutil.easter import easter
+
+
+#  Test that dateutil.parser-related imports work properly
+def test_import_parser_direct():
+    import dateutil.parser
+
 
-    def testImportVersionStr(self):
-        from dateutil import __version__
+def test_import_parser_from():
+    from dateutil import parser
 
-    def testImportRoot(self):
-        import dateutil
 
-        self.assertTrue(hasattr(dateutil, '__version__'))
+def test_import_parser_all():
+    # All interface
+    from dateutil.parser import parse
+    from dateutil.parser import parserinfo
 
+    # Other public classes
+    from dateutil.parser import parser
 
-class ImportEasterTest(unittest.TestCase):
-    """ Test that dateutil.easter-related imports work properly """
+    for var in (parse, parserinfo, parser):
+        assert var is not None
 
-    def testEasterDirect(self):
-        import dateutil.easter
 
-    def testEasterFrom(self):
-        from dateutil import easter
+# Test that dateutil.relativedelta-related imports work properly
+def test_import_relative_delta_direct():
+    import dateutil.relativedelta
 
-    def testEasterStar(self):
-        from dateutil.easter import easter
 
+def test_import_relative_delta_from():
+    from dateutil import relativedelta
 
-class ImportParserTest(unittest.TestCase):
-    """ Test that dateutil.parser-related imports work properly """
-    def testParserDirect(self):
-        import dateutil.parser
+def test_import_relative_delta_all():
+    from dateutil.relativedelta import relativedelta
+    from dateutil.relativedelta import MO, TU, WE, TH, FR, SA, SU
 
-    def testParserFrom(self):
-        from dateutil import parser
+    for var in (relativedelta, MO, TU, WE, TH, FR, SA, SU):
+        assert var is not None
 
-    def testParserAll(self):
-        # All interface
-        from dateutil.parser import parse
-        from dateutil.parser import parserinfo
+    # In the public interface but not in all
+    from dateutil.relativedelta import weekday
+    assert weekday is not  None
 
-        # Other public classes
-        from dateutil.parser import parser
 
-        for var in (parse, parserinfo, parser):
-            self.assertIsNot(var, None)
+# Test that dateutil.rrule related imports work properly
+def test_import_rrule_direct():
+    import dateutil.rrule
 
 
-class ImportRelativeDeltaTest(unittest.TestCase):
-    """ Test that dateutil.relativedelta-related imports work properly """
-    def testRelativeDeltaDirect(self):
-        import dateutil.relativedelta
+def test_import_rrule_from():
+    from dateutil import rrule
 
-    def testRelativeDeltaFrom(self):
-        from dateutil import relativedelta
 
-    def testRelativeDeltaAll(self):
-        from dateutil.relativedelta import relativedelta
-        from dateutil.relativedelta import MO, TU, WE, TH, FR, SA, SU
+def test_import_rrule_all():
+    from dateutil.rrule import rrule
+    from dateutil.rrule import rruleset
+    from dateutil.rrule import rrulestr
+    from dateutil.rrule import YEARLY, MONTHLY, WEEKLY, DAILY
+    from dateutil.rrule import HOURLY, MINUTELY, SECONDLY
+    from dateutil.rrule import MO, TU, WE, TH, FR, SA, SU
 
-        for var in (relativedelta, MO, TU, WE, TH, FR, SA, SU):
-            self.assertIsNot(var, None)
+    rr_all = (rrule, rruleset, rrulestr,
+              YEARLY, MONTHLY, WEEKLY, DAILY,
+              HOURLY, MINUTELY, SECONDLY,
+              MO, TU, WE, TH, FR, SA, SU)
 
-        # In the public interface but not in all
-        from dateutil.relativedelta import weekday
-        self.assertIsNot(weekday, None)
+    for var in rr_all:
+       assert var is not None
 
+    # In the public interface but not in all
+    from dateutil.rrule import weekday
+    assert weekday is not None
 
-class ImportRRuleTest(unittest.TestCase):
-    """ Test that dateutil.rrule related imports work properly """
-    def testRRuleDirect(self):
-        import dateutil.rrule
 
-    def testRRuleFrom(self):
-        from dateutil import rrule
+# Test that dateutil.tz related imports work properly
+def test_import_tztest_direct():
+    import dateutil.tz
 
-    def testRRuleAll(self):
-        from dateutil.rrule import rrule
-        from dateutil.rrule import rruleset
-        from dateutil.rrule import rrulestr
-        from dateutil.rrule import YEARLY, MONTHLY, WEEKLY, DAILY
-        from dateutil.rrule import HOURLY, MINUTELY, SECONDLY
-        from dateutil.rrule import MO, TU, WE, TH, FR, SA, SU
 
-        rr_all = (rrule, rruleset, rrulestr,
-                  YEARLY, MONTHLY, WEEKLY, DAILY,
-                  HOURLY, MINUTELY, SECONDLY,
-                  MO, TU, WE, TH, FR, SA, SU)
+def test_import_tz_from():
+    from dateutil import tz
 
-        for var in rr_all:
-            self.assertIsNot(var, None)
 
-        # In the public interface but not in all
-        from dateutil.rrule import weekday
-        self.assertIsNot(weekday, None)
+def test_import_tz_all():
+    from dateutil.tz import tzutc
+    from dateutil.tz import tzoffset
+    from dateutil.tz import tzlocal
+    from dateutil.tz import tzfile
+    from dateutil.tz import tzrange
+    from dateutil.tz import tzstr
+    from dateutil.tz import tzical
+    from dateutil.tz import gettz
+    from dateutil.tz import tzwin
+    from dateutil.tz import tzwinlocal
+    from dateutil.tz import UTC
+    from dateutil.tz import datetime_ambiguous
+    from dateutil.tz import datetime_exists
+    from dateutil.tz import resolve_imaginary
 
+    tz_all = ["tzutc", "tzoffset", "tzlocal", "tzfile", "tzrange",
+              "tzstr", "tzical", "gettz", "datetime_ambiguous",
+              "datetime_exists", "resolve_imaginary", "UTC"]
 
-class ImportTZTest(unittest.TestCase):
-    """ Test that dateutil.tz related imports work properly """
-    def testTzDirect(self):
-        import dateutil.tz
+    tz_all += ["tzwin", "tzwinlocal"] if sys.platform.startswith("win") else []
+    lvars = locals()
 
-    def testTzFrom(self):
-        from dateutil import tz
+    for var in tz_all:
+        assert lvars[var] is not None
 
-    def testTzAll(self):
-        from dateutil.tz import tzutc
-        from dateutil.tz import tzoffset
-        from dateutil.tz import tzlocal
-        from dateutil.tz import tzfile
-        from dateutil.tz import tzrange
-        from dateutil.tz import tzstr
-        from dateutil.tz import tzical
-        from dateutil.tz import gettz
-        from dateutil.tz import tzwin
-        from dateutil.tz import tzwinlocal
-        from dateutil.tz import UTC
-        from dateutil.tz import datetime_ambiguous
-        from dateutil.tz import datetime_exists
-        from dateutil.tz import resolve_imaginary
+# Test that dateutil.tzwin related imports work properly
+@pytest.mark.skipif(not HOST_IS_WINDOWS, reason="Requires Windows")
+def test_import_tz_windows_direct():
+    import dateutil.tzwin
 
-        tz_all = ["tzutc", "tzoffset", "tzlocal", "tzfile", "tzrange",
-                  "tzstr", "tzical", "gettz", "datetime_ambiguous",
-                  "datetime_exists", "resolve_imaginary", "UTC"]
 
-        tz_all += ["tzwin", "tzwinlocal"] if sys.platform.startswith("win") else []
-        lvars = locals()
+@pytest.mark.skipif(not HOST_IS_WINDOWS, reason="Requires Windows")
+def test_import_tz_windows_from():
+    from dateutil import tzwin
 
-        for var in tz_all:
-            self.assertIsNot(lvars[var], None)
 
-@unittest.skipUnless(sys.platform.startswith('win'), "Requires Windows")
-class ImportTZWinTest(unittest.TestCase):
-    """ Test that dateutil.tzwin related imports work properly """
-    def testTzwinDirect(self):
-        import dateutil.tzwin
+@pytest.mark.skipif(not HOST_IS_WINDOWS, reason="Requires Windows")
+def test_import_tz_windows_star():
+    from dateutil.tzwin import tzwin
+    from dateutil.tzwin import tzwinlocal
 
-    def testTzwinFrom(self):
-        from dateutil import tzwin
+    tzwin_all = [tzwin, tzwinlocal]
 
-    def testTzwinStar(self):
-        from dateutil.tzwin import tzwin
-        from dateutil.tzwin import tzwinlocal
+    for var in tzwin_all:
+        assert var is not None
 
-        tzwin_all = [tzwin, tzwinlocal]
 
-        for var in tzwin_all:
-            self.assertIsNot(var, None)
+# Test imports of Zone Info
+def test_import_zone_info_direct():
+    import dateutil.zoneinfo
 
 
-class ImportZoneInfoTest(unittest.TestCase):
-    def testZoneinfoDirect(self):
-        import dateutil.zoneinfo
+def test_import_zone_info_from():
+    from dateutil import zoneinfo
 
-    def testZoneinfoFrom(self):
-        from dateutil import zoneinfo
 
-    def testZoneinfoStar(self):
-        from dateutil.zoneinfo import gettz
-        from dateutil.zoneinfo import gettz_db_metadata
-        from dateutil.zoneinfo import rebuild
+def test_import_zone_info_star():
+    from dateutil.zoneinfo import gettz
+    from dateutil.zoneinfo import gettz_db_metadata
+    from dateutil.zoneinfo import rebuild
 
-        zi_all = (gettz, gettz_db_metadata, rebuild)
+    zi_all = (gettz, gettz_db_metadata, rebuild)
 
-        for var in zi_all:
-            self.assertIsNot(var, None)
+    for var in zi_all:
+        assert var is not None

dateutil/test/test_utils.py

@@ -2,8 +2,6 @@
 from __future__ import unicode_literals
 from datetime import timedelta, datetime
 
-import unittest
-
 from dateutil import tz
 from dateutil import utils
 from dateutil.tz import UTC
@@ -14,40 +12,41 @@
 NYC = tz.gettz("America/New_York")
 
 
-class UtilsTest(unittest.TestCase):
-    @freeze_time(datetime(2014, 12, 15, 1, 21, 33, 4003))
-    def testToday(self):
-        self.assertEqual(utils.today(), datetime(2014, 12, 15, 0, 0, 0))
+@freeze_time(datetime(2014, 12, 15, 1, 21, 33, 4003))
+def test_utils_today():
+    assert utils.today() == datetime(2014, 12, 15, 0, 0, 0)
+
+
+@freeze_time(datetime(2014, 12, 15, 12), tz_offset=5)
+def test_utils_today_tz_info():
+    assert utils.today(NYC) == datetime(2014, 12, 15, 0, 0, 0, tzinfo=NYC)
+
+
+@freeze_time(datetime(2014, 12, 15, 23), tz_offset=5)
+def test_utils_today_tz_info_different_day():
+    assert utils.today(UTC) == datetime(2014, 12, 16, 0, 0, 0, tzinfo=UTC)
+
+
+def test_utils_default_tz_info_naive():
+    dt = datetime(2014, 9, 14, 9, 30)
+    assert utils.default_tzinfo(dt, NYC).tzinfo is NYC
 
-    @freeze_time(datetime(2014, 12, 15, 12), tz_offset=5)
-    def testTodayTzInfo(self):
-        self.assertEqual(utils.today(NYC),
-                         datetime(2014, 12, 15, 0, 0, 0, tzinfo=NYC))
 
-    @freeze_time(datetime(2014, 12, 15, 23), tz_offset=5)
-    def testTodayTzInfoDifferentDay(self):
-        self.assertEqual(utils.today(UTC),
-                         datetime(2014, 12, 16, 0, 0, 0, tzinfo=UTC))
+def test_utils_default_tz_info_aware():
+    dt = datetime(2014, 9, 14, 9, 30, tzinfo=UTC)
+    assert utils.default_tzinfo(dt, NYC).tzinfo is UTC
 
-    def testDefaultTZInfoNaive(self):
-        dt = datetime(2014, 9, 14, 9, 30)
-        self.assertIs(utils.default_tzinfo(dt, NYC).tzinfo,
-                      NYC)
 
-    def testDefaultTZInfoAware(self):
-        dt = datetime(2014, 9, 14, 9, 30, tzinfo=UTC)
-        self.assertIs(utils.default_tzinfo(dt, NYC).tzinfo,
-                      UTC)
+def test_utils_within_delta():
+    d1 = datetime(2016, 1, 1, 12, 14, 1, 9)
+    d2 = d1.replace(microsecond=15)
 
-    def testWithinDelta(self):
-        d1 = datetime(2016, 1, 1, 12, 14, 1, 9)
-        d2 = d1.replace(microsecond=15)
+    assert within_delta(d1, d2, timedelta(seconds=1))
+    assert not within_delta(d1, d2, timedelta(microseconds=1))
 
-        self.assertTrue(within_delta(d1, d2, timedelta(seconds=1)))
-        self.assertFalse(within_delta(d1, d2, timedelta(microseconds=1)))
 
-    def testWithinDeltaWithNegativeDelta(self):
-        d1 = datetime(2016, 1, 1)
-        d2 = datetime(2015, 12, 31)
+def test_utils_within_delta_with_negative_delta():
+    d1 = datetime(2016, 1, 1)
+    d2 = datetime(2015, 12, 31)
 
-        self.assertTrue(within_delta(d2, d1, timedelta(days=-1)))
+    assert within_delta(d2, d1, timedelta(days=-1))