New generative tests for worker.py, and repo tidy

Author: 4OH4

app/core/database.py

@@ -20,20 +20,22 @@
 import sqlite3
 
 class DAO(object):
-    """Sqlite3 database DAO for Pytesting demo application
-        Handles a database table for job information:
-        job title, job ID, company name, job salary
-
-        Usage:
-        >>> dao = DAO('example.db')
-        Database connection initialised
-        >>> dao.create_jobs_table()
-        >>> dao.insert_job('Cook','Tasty Food Shack',11000,'11/06/2019')
-        1
-        >>> dao.query_job(1)
-        ('Cook', 1, 'Tasty Food Shack', 11000, '11/06/2019')
-        >>> dao.close()
-        >>> dao.delete_db()
+    """
+    Sqlite3 database DAO for Pytesting demo application
+    Handles a database table for job information:
+    job title, job ID, company name, job salary
+
+    Usage:
+    >>> dao = DAO('example.db')
+    Database connection initialised
+    >>> dao.create_jobs_table()
+    >>> dao.insert_job('Cook','Tasty Food Shack',11000,'11/06/2019')
+    1
+    >>> dao.query_job(1)
+    ('Cook', 1, 'Tasty Food Shack', 11000, '11/06/2019')
+    >>> dao.close()
+    >>> dao.delete_db()
+
     """
 
     def __init__(self, db_filepath='example.db'):

app/core/worker.py

@@ -9,7 +9,7 @@
 """
 
 # Conversion map for three-letter months
-short_months = {'Jan': 1, 'Feb': 1, 'Mar': 3, 'Apr': 4, 'May': 5, 'June': 6,
+short_months = {'Jan': 1, 'Feb': 1, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
                 'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
 
 # Data file format (columns)
@@ -34,7 +34,7 @@ def readData(self, data_filepath):
 
         for temp_line in in_file.readlines():
 
-            parsed = self.parseLine(temp_line)
+            parsed = self.parseLineCSV(temp_line)
             if parsed is not None:
                 output_data.append(parsed)
 
@@ -44,8 +44,7 @@ def readData(self, data_filepath):
 
         return output_data
 
-
-    def parseLine(self, input_string):
+    def parseLineCSV(self, input_string):
         """
         Parse a single row of input data, and run rudimentary checks
 
@@ -70,34 +69,23 @@ def parseLine(self, input_string):
                 }
 
         return result
-
-                
 
     def parseDate(self, input_string):
         """ 
-        Parses an input string, and extracts integer values for day, month and year
+        Parses an input string, and extracts a date in ddmmmYYYY format.
+        Returns result in ISO8601 timestamp format
 
-        N.B. this function is deliberately lacking in robust validation and checking of the input data
+        N.B. this function is deliberately lacking in robust validation and checking of the input data.
+        This functionality may be better handled by the datetime module, although as a demonstration
+        it is written from scratch.
 
-        :param input_string: (string) hopefully containing a date in one of the two recognised formats
-        :returns result: (string) parsed date in dd/mm/YYYY format
+        :param input_string: (string) hopefully containing a date in the recognised format
+        :returns result: (string) parsed date in YYYY-mm-dd format
         """
         result_string = None
-        # Date format 1: dd/mm/yy     e.g. 01/09/19
-        split_parts = input_string.split('/')
-        if len(split_parts) == 3:
-            dd = int(split_parts[0])
-            mm = int(split_parts[1])
-            YYYY = 2000 + int(split_parts[2])
-            
-            # Test and assemble output
-            if (dd>0) and (dd<=31) and \
-                (mm>0) and (mm<=12) and \
-                (YYYY>2000) and (YYYY<2100):
-                    result_string = f'{dd:02}/{mm:02}/{YYYY}'
-
-        # Date format 2: ddmmmYYYY    09Jan2019
-        elif any(month in input_string for month in short_months.keys()):
+
+        # Date format: ddmmmYYYY   e.g. 09Jan2019
+        if any(month.lower() in input_string.lower() for month in short_months.keys()):
             # One of the three letter month strings is in the input
             match = next(month for month in short_months.keys() if month in input_string)
             split_parts = input_string.split(match)
@@ -107,10 +95,7 @@ def parseDate(self, input_string):
                 YYYY = int(split_parts[1])
 
                 # Test and assemble output
-                if (dd>0) and (dd<=31) and \
-                    (YYYY>2000) and (YYYY<2100):
-                    result_string = f'{dd:02}/{mm:02}/{YYYY}'
-                
-#        else: # Unknown date format
+                if (dd>0) and (dd<=31): # and (YYYY>2000) and (YYYY<2100):
+                    result_string = f'{YYYY}-{mm:02}-{dd:02}'
 
         return result_string

app/tests/test_worker.py

@@ -12,6 +12,7 @@
 
 """
 
+import pytest
 from truth.truth import AssertThat
 
 # Module under test
@@ -20,31 +21,31 @@
 
 def test_parseLine1(mocker):
     """ 
-    Test parseLine with good data (all fields present)
+    Test parseLineCSV with good data (all fields present)
 
-    Expected result: dict returne with data
+    Expected result: dict returned with data
     """
 
     # given: setup test framework
     worker = Worker()
-    testString = "11/11/19,Teacher,Brighter Futures,12000"
+    testString = "12Nov2019,Teacher,Brighter Futures,12000"
     expectedResult = {
-                    'date': '11/11/2019',
+                    'date': '2019-11-12',
                     'job_title': 'Teacher',
                     'company_name': 'Brighter Futures',
                     'salary': 12000
                 }
 
     # when:
-    result = worker.parseLine(testString)
+    result = worker.parseLineCSV(testString)
 
     # then:
     assert result == expectedResult
 
 
 def test_parseLine2(mocker):
     """ 
-    Test parseLine with bad data (some fields missing)
+    Test parseLineCSV with bad data (some fields missing)
 
     Expected result: result is None
     """
@@ -54,22 +55,22 @@ def test_parseLine2(mocker):
     testString = "11/11/19,Brighter Futures,12000"
 
     # when:
-    result = worker.parseLine(testString)
+    result = worker.parseLineCSV(testString)
 
     # then: (Using PyTruth assertions)
     AssertThat(result).IsNone()
 
 
 def test_parseDate1(mocker):
     """ 
-    Test parseLine with Date format 1: dd/mm/yy
+    Test parseDate with date format: ddmmmYYYY
 
-    Expected result: formatted string in dd/mm/YYYY
+    Expected result: formatted string in YYYY-mm-dd
     """    
     # given: setup test framework
     worker = Worker()
-    testString = "01/12/20"
-    expected_result = "01/12/2020"
+    testString = "01Dec2020"
+    expected_result = "2020-12-01"
 
     # when:
     result = worker.parseDate(testString)
@@ -80,14 +81,14 @@ def test_parseDate1(mocker):
 
 def test_parseDate2(mocker):
     """ 
-    Test parseLine with Date format 2: ddmmmYYYY
+    Test parseDate with date format: ddmmmYYYY
 
-    Expected result: formatted string in dd/mm/YYYY
+    Expected result: formatted string in YYYY-mm-dd
     """    
     # given: setup test framework
     worker = Worker()
     testString = "04Jan2019"
-    expected_result = "04/01/2019"
+    expected_result = "2019-01-04"
 
     # when:
     result = worker.parseDate(testString)
@@ -96,35 +97,49 @@ def test_parseDate2(mocker):
     AssertThat(result).IsEqualTo(expected_result)
 
 
+@pytest.mark.xfail  # This test case is currently expected to fail
 def test_parseDate3(mocker):
     """ 
-    Test parseLine with bad Date format 1: dd/mmyy
+    Test parseDate with unusual input
 
     Expected result: result is None
+
+    N.B. Worker.parseDate doesn't implement robust input validation, so will
+    trigger an unhandled exception when fed non-string inputs. Hence, this
+    test case is currently expected to fail.
+
     """    
     # given: setup test framework
     worker = Worker()
-    testString = "12/1220"
+    input_strings = ["12/1220", "01/01/19999", "Monday", -1, [], {"hello": "world"}, 3.5] 
 
     # when:
-    result = worker.parseDate(testString)
-    
-    # then:
-    AssertThat(result).IsNone()
+    for input_string in input_strings:
+        result = worker.parseDate(input_string)
+        
+        # then:
+        AssertThat(result).IsNone()
 
 
+@pytest.mark.xfail  # This test case is currently expected to fail
 def test_parseDate4(mocker):
     """ 
-    Test parseLine with bad Date format 2: 32Jan2019
+    Test parseDate with unusual input
 
     Expected result: result is None
+
+    N.B. Worker.parseDate contains some complicated logic, that can get tripped
+    by some unusual input - in this case a real-world date format "19th June 2020".
+    Hence, this test case is currently expected to fail.
+
     """    
     # given: setup test framework
     worker = Worker()
-    testString = "32Jan2019"
+    input_strings = ["32Jan2019", "Tuesday", "19th June 2020"]
 
     # when:
-    result = worker.parseDate(testString)
+    for input_string in input_strings:
+        result = worker.parseDate(input_string)
 
     # then:
-    AssertThat(result).IsNone()
+        AssertThat(result).IsNone()

app/tests/test_worker_generative.py

@@ -12,7 +12,10 @@
 
 """
 
-from hypothesis.strategies import text
+import datetime
+from string import printable  # digits + ascii_letters + punctuation + whitespace
+
+from hypothesis.strategies import text, dates
 from hypothesis import given
 
 from truth.truth import AssertThat
@@ -21,22 +24,51 @@
 from app.core.worker import Worker
 
 
-@given(text())
-def test_worker_parseLine_generative(input):
-
+# Generate strings using all printable characters, except forward slashes
+@given(input_string=text(alphabet=[char for char in printable if char !=',']))
+def test_worker_parseLineCSV_generative(input_string):
+    
+    # given
     worker = Worker()
 
-    AssertThat(worker.parseLine(input)).IsNone()
-
-
-# from hypothesis.strategies import date
+    # when
+    result = worker.parseLineCSV(input_string)
+    
+    # then
+    AssertThat(result).IsNone()
 
-# @given(date())
-# def test_worker_parseDate1_generative(input):
 
-#     worker = Worker()
-
-#     AssertThat(worker.parseLine(input)).IsString()
+# Generate dates within the four digit year range
+@given(input_date=dates(min_value=datetime.date(1000, 1, 1), max_value=datetime.date(9999, 1, 1)))
+def test_worker_parseDate1_generative(mocker, input_date):
 
+    # given
+    input_string = input_date.strftime(format="%d%b%Y")
+    worker = Worker()
 
+    # when 
+    result = worker.parseDate(input_string)
+    
+    print(input_string, result)
+    
+    # then
+    AssertThat(result).IsInstanceOf(str)
+    AssertThat(result).HasSize(10)
+    AssertThat(result.split('-')).HasSize(3)
+
+
+# Generate strings using all printable characters, except forward slashes
+@given(input_string=text())
+def test_worker_parseDate2_generative(input_string):
+    
+    # given
+    worker = Worker()
 
+    # when
+    result = worker.parseLineCSV(input_string)
+    
+    # then
+    # returns None or a string
+    # Must not throw unhandled exception
+    if result is not None:
+        AssertThat(result).IsInstanceOf(str)

pytest.ini

@@ -1,5 +1,5 @@
 [pytest]
-
+filterwarnings=ignore::DeprecationWarning
 norecursedirs=dist data
 addopts =
   --doctest-modules

requirements.txt

@@ -1,6 +1,6 @@
 attrs>=19.2.0
-pytest
-pytest-cov
-pytest-mock
-pytruth
-hypothesis
+pytest~=5.3
+pytest-cov~=2.8
+pytest-mock~=1.13
+pytruth~=1.1
+hypothesis~=4.56