fixed use of time strings to allow both seconds and second etc (#112)

* fixed use of time strings to allow both  and  etc

* fixed use of time strings to allow both 'seconds' and 'second' etc

* revised unit tests to use parameterized approach

* changed utils tests to pytest

Author: ronanstokes-db

CONTRIBUTING.md

@@ -77,6 +77,11 @@ Run  `make clean dist` from the main project directory.
 
 # Testing 
 
+## Creating tests
+Preferred style is to use pytest rather than unittest but some unittest based code is used in compatibility mode.
+
+Any new tests should be written as pytest compatible test classes.
+
 ## Running unit / integration tests
 
 If using an environment with multiple Python versions, make sure to use virtual env or 

dbldatagen/utils.py

@@ -196,9 +196,9 @@ def parse_time_interval(spec):
             hours = time_value
         elif time_type in ["minutes", "minute"]:
             minutes = time_value
-        elif time_type in ["seconds", "seconds"]:
+        elif time_type in ["seconds", "second"]:
             seconds = time_value
-        elif time_type in ["microseconds", "microseconds"]:
+        elif time_type in ["microseconds", "microsecond"]:
             microseconds = time_value
         elif time_type in ["milliseconds", "millisecond"]:
             milliseconds = time_value

tests/test_utils.py

@@ -1,96 +1,81 @@
 import logging
-import unittest
+import sys
 from datetime import timedelta
+import pytest
 
 from dbldatagen import ensure, mkBoundsList, coalesce_values, deprecated, SparkSingleton, \
     parse_time_interval, DataGenError
 
 spark = SparkSingleton.getLocalInstance("unit tests")
 
 
-class TestUtils(unittest.TestCase):
+class TestUtils:
     x = 1
 
-    def setUp(self):
-        print("setting up")
-        FORMAT = '%(asctime)-15s %(message)s'
-        logging.basicConfig(format=FORMAT)
-
-    @classmethod
-    def setUpClass(cls):
-        pass
+    @pytest.fixture(autouse=True)
+    def setupLogger(self):
+        self.logger = logging.getLogger("TestUtils")
 
     @deprecated("testing deprecated")
     def testDeprecatedMethod(self):
         pass
 
-    @unittest.expectedFailure
     def test_ensure(self):
-        ensure(1 == 2, "Expected error")
+        with pytest.raises(Exception):
+            ensure(1 == 2, "Expected error")
 
-    def testMkBoundsList1(self):
+    def test_mkBoundsList1(self):
         """ Test utils mkBoundsList"""
         test = mkBoundsList(None, 1)
 
-        self.assertEqual(len(test), 2)
+        assert len(test) == 2
 
         test2 = mkBoundsList(None, [1, 1])
 
-        self.assertEqual(len(test2), 2)
+        assert len(test2) ==  2
 
-    def testCoalesce(self):
+    @pytest.mark.parametrize("test_input,expected",
+                             [
+                                 ([None, 1],  1),
+                                 ([2, 1],  2),
+                                 ([3, None, 1], 3),
+                                 ([None, None, None], None),
+                             ])
+    def test_coalesce(self, test_input, expected):
         """ Test utils coalesce function"""
-        result = coalesce_values(None, 1)
-
-        self.assertEqual(result, 1)
-
-        result2 = coalesce_values(3, None, 1)
-
-        self.assertEqual(result2, 3)
-
-        result3 = coalesce_values(None, None, None)
-
-        self.assertIsNone(result3)
-
-    def testParseTimeInterval1(self):
-        interval = parse_time_interval("1 hours")
-        self.assertEqual(timedelta(hours=1), interval)
+        result = coalesce_values(*test_input)
+        assert result == expected
+
+    @pytest.mark.parametrize("test_input,expected",
+                             [
+                                 ("1 hours, minutes = 2",  timedelta(hours=1, minutes=2)),
+                                 ("4 days, 1 hours, 2 minutes", timedelta(days=4, hours=1, minutes=2)),
+                                 ("days=4, hours=1, minutes=2", timedelta(days=4, hours=1, minutes=2)),
+                                 ("1 hours, 2 seconds", timedelta(hours=1, seconds=2)),
+                                 ("1 hours, 2 minutes", timedelta(hours=1, minutes=2)),
+                                 ("1 hours", timedelta(hours=1)),
+                                 ("1 hour", timedelta(hours=1)),
+                                 ("1 hour, 1 second", timedelta(hours=1, seconds=1)),
+                                 ("1 hour, 10 milliseconds", timedelta(hours=1, milliseconds=10)),
+                                 ("1 hour, 10 microseconds", timedelta(hours=1, microseconds=10)),
+                                 ("1 year, 4 weeks", timedelta(weeks=56))
+                             ])
+    def testParseTimeInterval2b(self, test_input, expected):
+        interval = parse_time_interval(test_input)
+        assert expected == interval
 
-    def testParseTimeInterval2(self):
-        interval = parse_time_interval("1 hours, 2 seconds")
-        self.assertEqual(timedelta(hours=1, seconds=2), interval)
-
-    def testParseTimeInterval3(self):
-        interval = parse_time_interval("1 hours, 2 minutes")
-        self.assertEqual(timedelta(hours=1, minutes=2), interval)
-
-    def testParseTimeInterval4(self):
-        interval = parse_time_interval("4 days, 1 hours, 2 minutes")
-        self.assertEqual(timedelta(days=4, hours=1, minutes=2), interval)
-
-    def testParseTimeInterval1a(self):
-        interval = parse_time_interval("hours=1")
-        self.assertEqual(timedelta(hours=1), interval)
-
-    def testParseTimeInterval2a(self):
-        interval = parse_time_interval("hours=1, seconds = 2")
-        self.assertEqual(timedelta(hours=1, seconds=2), interval)
+    def testDatagenExceptionObject(self):
+        testException = DataGenError("testing")
 
-    def testParseTimeInterval3a(self):
-        interval = parse_time_interval("1 hours, minutes = 2")
-        self.assertEqual(timedelta(hours=1, minutes=2), interval)
+        assert testException is not None
 
-    def testParseTimeInterval4a(self):
-        interval = parse_time_interval("days=4, hours=1, minutes=2")
-        self.assertEqual(timedelta(days=4, hours=1, minutes=2), interval)
+        assert type(repr(testException)) is str
+        self.logger.info(repr(testException))
 
-    def testDatagenExceptionObject(self):
-        testException = DataGenError("testing")
+        assert type(str(testException)) is str
+        self.logger.info(str(testException))
 
-        self.assertIsNotNone(testException)
 
-        print("error has repr", repr(testException))
-        print("error has str", str(testException))
 
 # run the tests
 # if __name__ == '__main__':