Revamp functions used in the Python test demo, and their corresponding tests

Author: IshaanDesai

05_testing_and_ci/examples/python_testing/mean_data.csv

@@ -2,62 +2,109 @@
 A set of mathematical operations.
 """
 
-
-def find_max(data):
-    """
-    Find maximum of all elements of a given list
-
-    Parameters
-    ----------
-    data : list
-        List of data. Elements are numbers
-
-    Returns
-    -------
-    find_max : float
-        Maximum of list
-    """
-    # Check that the input list has numbers
-    for n in data:
-        assert type(n) == int or type(n) == float
-
-    max_num = data[0]  # Assume the first number is the maximum
-    for n in data:
-        if n > max_num:
-            max_num = n
-
-    return max_num
-
-
-def find_mean(data):
-    """
-    Find mean of all elements of a given list
-
-    Parameters
-    ----------
-    data : list
-        List of data. Elements are numbers
-
-    Returns
-    -------
-    float : float
-        Mean of list
-    """
-    # Check that the input list has numbers
-    for n in data:
-        assert type(n) == int or type(n) == float
-
-    return sum(data) / len(data)
+class MathOperations:
+
+    def __init__(self, data):
+        self._data = data
+
+    def reorder_data(self):
+        """
+        Reorder data in ascending order
+        """
+        self._data.sort()
+
+    def find_max(self):
+        """
+        Find maximum of all elements of a given list
+        Parameters
+        ----------
+        data : list
+            List of data. Elements are numbers
+
+        Returns
+        -------
+        find_max : float
+            Maximum of list
+        """
+        # Check that the input list has numbers
+        for n in self._data:
+            assert type(n) == int or type(n) == float
+
+        max_num = self._data[0]  # Assume the first number is the maximum
+        for n in self._data:
+            if n > max_num:
+                max_num = n
+
+        return max_num
+
+    def find_median(self):
+        """
+        Find median of all elements of a given list
+
+        Parameters
+        ----------
+        data : list
+            List of data. Elements are numbers
+
+        Returns
+        -------
+        float : float
+            Median of list
+        """
+        # Check that the input list has numbers
+        for n in self._data:
+            assert type(n) == int or type(n) == float
+
+        # Sort the data to find the median
+        sorted_data = sorted(self._data)
+        n = len(sorted_data)
+        
+        # If odd number of elements, return the middle one
+        if n % 2 == 1:
+            return sorted_data[n // 2]
+        # If even number of elements, return the average of the two middle ones
+        else:
+            mid1 = sorted_data[n // 2 - 1]
+            mid2 = sorted_data[n // 2]
+            return (mid1 + mid2) / 2
+
+    def find_mean(self):
+        """
+        Find mean of all elements of a given list
+
+        Parameters
+        ----------
+        data : list
+            List of data. Elements are numbers
+
+        Returns
+        -------
+        float : float
+            Mean of list
+        """
+        # Check that the input list has numbers
+        for n in self._data:
+            assert type(n) == int or type(n) == float
+
+        total = sum(self._data)
+        count = len(self._data)
+        mean = total / count
+        return mean
 
 
 def main():
-    data = [5, 3, 14, 27, 4, 9]
+    data = [5, 3, 14, 27, 4, 9, 53]
+
+    math_ops = MathOperations(data)
 
-    maximum = find_max(data)
+    maximum = math_ops.find_max()
     print("Maximum of {} is {}".format(data, maximum))
 
-    mean = find_mean(data)
-    print("Average of {} is {}".format(data, mean))
+    median = math_ops.find_median()
+    print("Median of {} is {}".format(data, median))
+
+    mean = math_ops.find_mean()
+    print("Mean of {} is {}".format(data, mean))
 
 
 if __name__ == "__main__":

05_testing_and_ci/examples/python_testing/operations.py

@@ -0,0 +1 @@
+1,17,18,32,43,167,209

05_testing_and_ci/examples/python_testing/reordered_data.csv

@@ -2,87 +2,91 @@
 Tests for mathematical operations functions.
 """
 
-from operations import find_max, find_mean
+from operations import MathOperations
 import pytest
 import csv
 
 
+@pytest.fixture
+def math_operations():
+    """
+    Fixture for MathOperations class
+    """
+    data = [43, 32, 167, 18, 1, 209, 17]
+    return MathOperations(data)
+
 # Unit test
-def test_find_max():
+def test_find_max(math_operations):
     """
     Test operations.find_max 
     """
-    # Fixture
-    data = [43, 32, 167, 18, 1, 209]
-
     # Expected result
     expected_max = 209
 
     # Actual result
-    actual_max = find_max(data)
+    actual_max = math_operations.find_max()
 
     # Test
     assert actual_max == expected_max
 
+# Unit test
+def test_reorder_data(math_operations):
+    """
+    Test operations.reorder_data
+    """
+    # Expected result
+    expected_data = [1, 17, 18, 32, 43, 167, 209]
+
+    # Actual result
+    math_operations.reorder_data()
+    actual_data = math_operations._data
+
+    # Test
+    assert actual_data == expected_data
 
 # Unit test
-def test_find_mean():
+def test_find_mean(math_operations):
     """
     Test operations.find_mean
     """
-    # Fixture
-    data = [43, 32, 167, 18, 1, 209]
-    
     # Expected result
-    expected_mean = 78.33
-    # expected_mean = pytest.approx(78.33, abs=0.01)
-    
+    expected_mean = 69.57
+
     # Actual result
-    actual_mean = find_mean(data)
-    
+    actual_mean = math_operations.find_mean()
+
     # Test
     assert actual_mean == expected_mean
 
-
 # Integration test
-def test_mean_of_max():
-    """
-    Test operations.find_max and operations.find_mean
+def test_find_median(math_operations):
     """
-    # Fixture
-    data1 = [43, 32, 167, 18, 1, 209]
-    data2 = [3, 13, 33, 23, 498]
-
+    Test operations.find_median
+    """   
     # Expected result
-    expected_mean_of_max = 353.5
-
-    maximum1 = find_max(data1)
-    maximum2 = find_max(data2)
-
+    expected_median = 32
+    
     # Actual result
-    actual_mean_of_max = find_mean([maximum1, maximum2])
+    actual_median = math_operations.find_median()
 
     # Test
-    assert actual_mean_of_max == expected_mean_of_max
+    assert actual_median == expected_median
 
 
 # Regression test
-def test_regression_mean():
+def test_reg_reorder_data(math_operations):
     """
-    Test operations.find_mean on a previously generated dataset
+    Test operations.reorder_data with data from CSV file
     """
-    with open("mean_data.csv") as f:
+    with open("reordered_data.csv") as f:
         rows = csv.reader(f, quoting=csv.QUOTE_NONNUMERIC)
-        # Fixture
-        data = next(rows)
-
-        # Expected result
-        reference_mean = next(rows)
+    
+        for row in rows:
+            expected_reordered_data = row
 
     # Actual result
-    actual_mean = find_mean(data)
-    
-    expected_mean = pytest.approx(reference_mean[0], abs=0.01)
-    
+    math_operations.reorder_data()
+    actual_reordered_data = math_operations._data
+
     # Test
-    assert actual_mean == expected_mean
+    assert actual_reordered_data == expected_reordered_data

05_testing_and_ci/examples/python_testing/test_operations.py

@@ -4,57 +4,26 @@ Example code is in [05_testing_and_ci/examples/python_testing](https://github.co
 
 ## Software Code Used
 
-- The file `operations.py` consists of two functions `find_max` and `find_mean` which calculate the maximum and mean of all elements of a list. The `main()` routine in the file applies the functions to a list and prints the output.
-- `main()` function in `operations.py` has assertion statements to check if the correct data type is passed to specific functions.
-- Assertion statements are the most basic way of testing code and are also used in unit and integration testing.
-- Tests are written in the file `test_operations.py`. The `test_*` prefix in the name is required so that pytest detects the file as a testing file. Suffix form `*_test.py` also works.
-- In all there are two unit tests, one integration test and one regression test.
-- The unit tests test the individual functions `find_max` and `find_mean`.
-- The integration test triggers both the functions `find_max` and `find_mean` and checks that the mean is less than the maximum, something that should always be true for a set of numbers.
-- The regression test first reads an old data set and a mean value from a CSV file. Then the function `find_mean` is run with the old data set and the new mean value is compared to the old one.
+The file [operations.py](examples/python_testing/operations.py) consists of a class `MathOperations` that has the following functions: `reorder_data`, `find_max`, `find_median`, and `find_mean`. The `main()` routine in the file applies the functions to a list and prints the output.
 
 ## pytest
 
 - pytest is installed using pip: `pip install pytest`.
 - All tests can be run using the command-line tool called `pytest`. Just type `pytest` in the working directory and hit ENTER.
 - If pytest is installed in some other way, you might need to run it like `python -m pytest`.
-- One test is expected to fail. Reading the error message we understand that the failure occurs because floating-point variable comparison is not handled correctly.
-- We need to tell pytest that while comparing two floating-point variables the value needs to be correct only up to a certain tolerance limit. To do this, the expected mean value needs to be changed by uncommenting the line in the following part of the code:
+- Tests are written in the file `test_operations.py`. The `test_*` prefix in the name is required so that pytest detects the file as a testing file. Suffix form `*_test.py` also works.
+- There are unit tests for the functions `reorder_data`, `find_max`, and `find_mean`.
+- There is an integration test for the function `find_median`, and a regression test for `reorder_data`. The regression test reads in a list from a CSV file.
+- The test fixture is defined under `@pytest.fixture`. pytest runs this once at the start and stores the returned output while running all other tests.
+- One test fails. Error message states that the failure occurs because floating-point variable comparison is not handled correctly.
+- While comparing two floating-point variables the value needs to be correct only up to a certain tolerance limit. To do this, the expected mean value needs to be changed in the following way:
 
 ```python
 # Expected result
-    expected_mean = 78.33
-    # expected_result = pytest.approx(78.3, abs=0.01)
-```
-
-- **Comparing floating point variables** needs to be handled in functions like `find_mean` and is done using `pytest.approx(value, abs)`. The `abs` value is the tolerance up to which the floating-point value will be checked, that is `78.33 +/- 0.01`.
-- Even if one test fails, pytest runs all the tests and gives a report on the failing test. The assertion failure report generated my pytest is also more detailed than the usual Python assertion report. When the test fails, the following is observed:
-
-```bash
-========================================== FAILURES ===============================================
-_______________________________________ test_find_mean ____________________________________________
-
-    def test_find_mean():
-        """
-        Test operations.find_mean
-        """
-        # Fixture
-        data = [43, 32, 167, 18, 1, 209]
-
-        # Expected result
-        expected_mean = 78.33
-        # expected_result = pytest.approx(78.33, abs=0.01)
-
-        # Actual result
-        actual_mean = find_mean(data)
-
-        # Test
->       assert actual_mean == expected_mean
-E       assert 78.33333333333333 == 78.33
-
-test_operations.py:44: AssertionError
+expected_mean = pytest.approx(69.57, rel=1e-2)
 ```
 
+- Even if one test fails, pytest runs the rest and gives a report on the failing test.
 - pytest not only points to the assertion but also prints out the test which has failed.
 - It is worth noting that pytest is also able to detect tests from other files and run them even if they are not in the conventional test formats.
 - pytest is able to detect tests in several forms of folder structures, and the folder structures have advantages and disadvantages. More information on this is in the [documentation](https://docs.pytest.org/en/6.2.x/goodpractices.html#choosing-a-test-layout-import-rules). In this demo we use the simplest folder structure where the source file and the test files are at the same directory level. Very often this is not the case. A more organized folder structure can be generated:

05_testing_and_ci/python_testing_demo.md

@@ -29,12 +29,12 @@ slideOptions:
 
 ## pytest
 
-- Library to write and manage tests.
-- Command-line tool also called `pytest`.
-- Install using pip: `pip install -U pytest`.
+- Package to write and manage tests.
+- Includes command-line interface called `pytest`.
+- Install using pip: `pip install pytest`.
 - All tests need to be in files named `test_*.py`.
 - Each test function needs to be named as `test_*`.
-- pytest gives a detailed description of assertion checks.
+- pytest gives a detailed description for failing tests.
 
 ---
 
@@ -48,6 +48,7 @@ slideOptions:
 - Many features like test automation, sharing of setup and shutdown of tests, etc.
 - Use the base class `unittest.TestCase` to create a test suite.
 - Command-line interface: `python -m unittest test_module1 test_module2 ...`.
+- Part of the Python standard library.
 
 ---