fix/test(replications): fix the algorithm find_position(), and add unit testing for it

Author: amyheather

simulation/replications.py

@@ -352,17 +352,22 @@ def find_position(self, lst):
             int:
                 Minimum replications required to meet and maintain precision.
         """
+        # Check if the list is empty or if no value is below the threshold
+        if not lst or all(x is None or x >= self.half_width_precision
+                          for x in lst):
+            return None
+
         # Find the first non-None value in the list
         start_index = pd.Series(lst).first_valid_index()
 
         # Iterate through the list, stopping when at last point where we still
         # have enough elements to look ahead
         if start_index is not None:
-            for i in range(start_index, len(lst) - self.look_ahead + 1):
+            for i in range(start_index, len(lst) - self.look_ahead):
                 # Create slice of list with current value + lookahead
                 # Check if all fall below the desired deviation
                 if all(value < self.half_width_precision
-                       for value in lst[i:i+self.look_ahead]):
+                       for value in lst[i:i+self.look_ahead+1]):
                     # Add one, so it is the number of reps, as is zero-indexed
                     return i + 1
         return None

tests/test_unittest_replications.py

@@ -210,3 +210,37 @@ def test_tabulizer_summary_table():
     assert df['lower_ci'].tolist() == [3, 8, 13]
     assert df['upper_ci'].tolist() == [7, 12, 17]
     assert df['deviation'].tolist() == [0.1, 0.2, 0.3]
+
+
+@pytest.mark.parametrize('lst, exp, look_ahead', [
+    ([None, None, 0.8, 0.4, 0.3], 4, 0),  # Normal case
+    ([0.4, 0.3, 0.2, 0.1], 1, 0),  # No None values
+    ([0.8, 0.9, 0.8, 0.7], None, 0),  # No values below threshold
+    ([None, None, None, None], None, 0),  # No values
+    ([], None, 0),  # Empty list
+    ([None, None, 0.8, 0.8, 0.3, 0.3, 0.3], None, 3),  # Not full lookahead
+    ([None, None, 0.8, 0.8, 0.3, 0.3, 0.3, 0.3], 5, 3)  # Meets lookahead
+])
+def test_find_position(lst, exp, look_ahead):
+    """
+    Test the find_position() method from ReplicationsAlgorithm.
+
+    Arguments:
+        lst (list)
+            List of values to input to find_position().
+        exp (float)
+            Expected result from find_position().
+        look_ahead (int)
+            Number of extra positions to check that they also fall under the
+            threshold.
+    """
+    # Set threshold to 0.5, with provided look_ahead
+    alg = ReplicationsAlgorithm(half_width_precision=0.5,
+                                look_ahead=look_ahead)
+
+    # Get result from algorithm and compare to expected
+    result = alg.find_position(lst)
+    assert result == exp, (
+        f'Ran find_position on: {lst} (threshold 0.5, look-ahead ' +
+        f'{look_ahead}). Expected {exp}, but got {result}.'
+    )