test(simulation): add tests inspired by llm_simpy repository

Author: amyheather

tests/test_functionaltest.py

@@ -0,0 +1,119 @@
+"""
+Functional testing
+
+Functional tests verify that the system or components perform their intended
+functionality.
+"""
+
+import pytest
+
+from simulation.parameters import (ASUArrivals, RehabArrivals, ASULOS,
+                                   RehabLOS, Param)
+from simulation.model import Model
+
+
+@pytest.mark.parametrize("warm_up_period", [(0), (1)])
+def test_audit_length(warm_up_period):
+    """
+    Given that we set an audit interval of 1, and that first audit is performed
+    at time 0, check that the length of the audit list matches the simulation
+    time (with no warm-up). Also, check that this is suitably reduced when a
+    warm-up period is implemented.
+
+    Parameters
+    ----------
+    warm_up_period: float
+        Length of the warm-up period in days.
+
+    Notes
+    -----
+    Inspired by `results_collection_test1`, `results_collection_test2` and
+    `test_warm_up` in github.com/pythonhealthdatascience/llm_simpy/.
+    """
+    # Run the model
+    param = Param(warm_up_period=warm_up_period,
+                  data_collection_period=10)
+    model = Model(param=param, run_number=0)
+    model.run()
+
+    # Check the length of the audit list
+    if warm_up_period == 0:
+        # Should have audits for timepoints 0 to 9 (so length of 10)
+        assert len(model.audit_list) == model.env.now == 10
+    elif warm_up_period == 1:
+        # With warm-up = 1, should have audits for timepoints 2 to 10 (so
+        # length of 9), as it is wiped at timepoint 1, so drop 0 and 1, but ran
+        # for one longer, so goes up to 10
+        assert len(model.audit_list) == model.env.now - warm_up_period - 1 == 9
+
+
+def test_high_iat():
+    """
+    Extreme value test, setting a very high inter-arrival time for all
+    patients, and so we expect no arrivals.
+
+    Notes
+    -----
+    Inspired by `ev_test_2` from github.com/pythonhealthdatascience/llm_simpy/.
+    """
+    # Set high inter-arrival time for all patient types
+    iat = 10_000_000
+    param = Param(
+        asu_arrivals=ASUArrivals(stroke=iat, tia=iat, neuro=iat, other=iat),
+        rehab_arrivals=RehabArrivals(stroke=iat, neuro=iat, other=iat))
+
+    # Run the model
+    model = Model(param=param, run_number=0)
+    model.run()
+
+    # Check that there are no arrivals
+    assert len(model.patients) == 0
+
+    # Check that the units are empty
+    assert model.asu_occupancy == 0
+    assert model.rehab_occupancy == 0
+
+
+@pytest.mark.parametrize("stroke_no_esd_mean", [(10_000_000), (5)])
+def test_long_los(stroke_no_esd_mean):
+    """
+    Extreme value test, setting a very long length of stay for:
+    1. All patients -> expect no patients to depart the model.
+    2. All except one type -> expect only those to depart the model (crudely
+    checked by seeing if occupancy is less than total arrivals).
+
+    Notes
+    -----
+    Inspired by `ev_test_3` and `test_ev_4` from
+    github.com/pythonhealthdatascience/llm_simpy/.
+    """
+    # Set high length of stay for all patient types except stroke_no_esd_mean.
+    # Also, no warm-up period, otherwise arrivals != occupancy (as arrivals
+    # excludes warm-up, but occupancy does not, if they are still present).
+    los = 10_000_000
+    param = Param(
+        asu_los=ASULOS(stroke_no_esd_mean=stroke_no_esd_mean,
+                       stroke_esd_mean=los,
+                       tia_mean=los,
+                       neuro_mean=los,
+                       other_mean=los),
+        rehab_los=RehabLOS(stroke_no_esd_mean=stroke_no_esd_mean,
+                           stroke_esd_mean=los,
+                           tia_mean=los,
+                           neuro_mean=los,
+                           other_mean=los),
+        warm_up_period=0)
+
+    # Run the model
+    model = Model(param=param, run_number=0)
+    model.run()
+
+    # Check that the total arrivals is equal to or less than total occupancy
+    total_occupancy = model.asu_occupancy + model.rehab_occupancy
+    if stroke_no_esd_mean == 10_000_000:
+        assert len(model.patients) == total_occupancy
+    elif stroke_no_esd_mean == 5:
+        assert len(model.patients) > total_occupancy
+
+
+# TODO: test_ev_5/6/7/8 - requires patient counts by unit and patient type

tests/test_unittest.py

@@ -1,5 +1,9 @@
 """
 Unit tests
+
+Unit tests are a type of functional testing that focuses on individual
+components (e.g. methods, classes) and tests them in isolation to ensure they
+work as intended.
 """
 
 from collections import namedtuple
@@ -11,6 +15,7 @@
     ASUArrivals, RehabArrivals, ASULOS, RehabLOS,
     ASURouting, RehabRouting, Param)
 from simulation.model import Model
+from simulation.runner import Runner
 
 
 # -----------------------------------------------------------------------------
@@ -124,3 +129,50 @@ def test_run_time():
     model.run()
     assert model.env.now == 21
     assert len(model.patients) > 0
+
+
+# -----------------------------------------------------------------------------
+# Runner
+# -----------------------------------------------------------------------------
+
+def test_get_occupancy_freq():
+    """
+    Test the `get_occupancy_freq` method works as expected.
+
+    Notes
+    -----
+    Inspired by `test_result_processing_1` and `test_result_processing_2` in
+    github.com/pythonhealthdatascience/llm_simpy/.
+    """
+    # Create test data
+    audit_list = []
+    for count, value in [(4, 1), (3, 2), (2, 3), (1, 4)]:
+        for _ in range(count):
+            audit_list.append({"asu_occupancy": value,
+                               "rehab_occupancy": value + 1})
+
+    # Define expected values for our test data
+    expected_beds = [1, 2, 3, 4]
+    expected_freq = [4, 3, 2, 1]
+    expected_pct = [0.4, 0.3, 0.2, 0.1]
+    expected_c_pct = [0.4, 0.7, 0.9, 1.0]
+    expected_prob_delay = [1.0, 0.3/0.7, 0.2/0.9, 0.1/1.0]
+
+    # Create a Runner instance
+    runner = Runner(None)
+
+    # Call the method
+    result_df = runner.get_occupancy_freq(audit_list, "asu")
+
+    # Check the structure of the DataFrame
+    assert list(result_df.columns) == [
+        "beds", "freq", "pct", "c_pct", "prob_delay"]
+
+    # Check the values
+    assert list(result_df["beds"]) == expected_beds
+    assert list(result_df["freq"]) == expected_freq
+    assert np.allclose(result_df["pct"], expected_pct)
+    assert np.allclose(result_df["c_pct"], expected_c_pct)
+
+    # Check prob_delay calculation
+    assert np.allclose(result_df["prob_delay"], expected_prob_delay)