floodmodeller-api 0.4.2.post1__py3-none-any.whl → 0.4.4__py3-none-any.whl

floodmodeller_api/test/test_ief.py

@@ -1,24 +1,136 @@
-import os
-
-import pytest
-
-from floodmodeller_api import IEF
-
-
-@pytest.fixture
-def ief_fp(test_workspace):
-    ief_fp = os.path.join(test_workspace, "network.ief")
-    return ief_fp
-
-
-@pytest.fixture
-def data_before(ief_fp):
-    with open(ief_fp, "r") as ief_file:
-        data_before = ief_file.read()
-    return data_before
-
-
-def test_ief_open_does_not_change_data(ief_fp, data_before):
-    """IEF: Test str representation equal to ief file with no changes"""
-    ief = IEF(ief_fp)
-    assert ief._write() == data_before
+from pathlib import Path
+from unittest.mock import call, patch
+
+import pytest
+
+from floodmodeller_api import IEF
+from floodmodeller_api.util import FloodModellerAPIError
+
+
+@pytest.fixture()
+def ief_fp(test_workspace: str) -> Path:
+    return Path(test_workspace, "network.ief")
+
+
+@pytest.fixture()
+def ief(ief_fp: Path) -> IEF:
+    return IEF(ief_fp)
+
+
+@pytest.fixture()
+def data_before(ief_fp: Path) -> str:
+    with open(ief_fp) as ief_file:
+        return ief_file.read()
+
+
+@pytest.fixture()
+def exe_bin(tmpdir) -> Path:
+    for exe in ["ISISf32.exe", "ISISf32_DoubleP.exe"]:
+        exe_path = Path(tmpdir, exe)
+        exe_path.touch()
+    return Path(tmpdir)
+
+
+@pytest.fixture()
+def p_open():
+    with patch("floodmodeller_api.ief.Popen") as p_open:
+        yield p_open
+
+
+@pytest.fixture()
+def sleep():
+    with patch("floodmodeller_api.ief.time.sleep") as sleep:
+        yield sleep
+
+
+def test_ief_open_does_not_change_data(ief: IEF, data_before: str):
+    """IEF: Test str representation equal to ief file with no changes"""
+    assert ief._write() == data_before
+
+
+@pytest.mark.usefixtures("log_timeout")
+@pytest.mark.parametrize(
+    ("precision", "method", "amend", "exe"),
+    [
+        ("DEFAULT", "WAIT", False, "ISISf32.exe"),
+        ("DEFAULT", "WAIT", True, "ISISf32_DoubleP.exe"),
+        ("SINGLE", "WAIT", False, "ISISf32.exe"),
+        ("SINGLE", "WAIT", True, "ISISf32.exe"),
+        ("DOUBLE", "WAIT", False, "ISISf32_DoubleP.exe"),
+        ("DOUBLE", "WAIT", True, "ISISf32_DoubleP.exe"),
+        ("DEFAULT", "RETURN_PROCESS", False, "ISISf32.exe"),
+        ("DEFAULT", "RETURN_PROCESS", True, "ISISf32_DoubleP.exe"),
+        ("SINGLE", "RETURN_PROCESS", False, "ISISf32.exe"),
+        ("SINGLE", "RETURN_PROCESS", True, "ISISf32.exe"),
+        ("DOUBLE", "RETURN_PROCESS", False, "ISISf32_DoubleP.exe"),
+        ("DOUBLE", "RETURN_PROCESS", True, "ISISf32_DoubleP.exe"),
+    ],
+)
+def test_simulate(
+    ief: IEF,
+    ief_fp: Path,
+    exe_bin: Path,
+    p_open,
+    sleep,
+    precision: str,
+    method: str,
+    amend: bool,
+    exe: str,
+):
+    if amend:
+        ief.launchdoubleprecisionversion = 1
+
+    p_open.return_value.poll.side_effect = [None, None, 0]
+
+    exe_path = Path(exe_bin, exe)
+    ief.simulate(method=method, precision=precision, enginespath=str(exe_bin))
+
+    p_open.assert_called_once_with(f'"{exe_path}" -sd "{ief_fp}"', cwd=str(ief_fp.parent))
+
+    if method == "WAIT":
+        assert p_open.return_value.poll.call_count == 3
+        assert sleep.call_args_list[-3:] == [call(0.1), call(1), call(1)]
+
+
+def test_simulate_error_without_bin(tmpdir, ief: IEF):
+    msg = (
+        r"\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+        r"\nAPI Error: Problem encountered when trying to simulate IEF file .*\."
+        r"\n"
+        r"\nDetails: .*-floodmodeller_api/ief\.py-\d+"
+        r"\nMsg: Flood Modeller non-default engine path not found! .*"
+        r"\n"
+        r"\nFor additional support, go to: https://github\.com/People-Places-Solutions/floodmodeller-api"
+    )
+    with pytest.raises(FloodModellerAPIError, match=msg):
+        ief.simulate(enginespath=str(Path(tmpdir, "bin")))
+
+
+def test_simulate_error_without_exe(tmpdir, ief: IEF):
+    msg = (
+        r"\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+        r"\nAPI Error: Problem encountered when trying to simulate IEF file .*\."
+        r"\n"
+        r"\nDetails: .*-floodmodeller_api/ief\.py-\d+"
+        r"\nMsg: Flood Modeller engine not found! Expected location: .*"
+        r"\n"
+        r"\nFor additional support, go to: https://github\.com/People-Places-Solutions/floodmodeller-api"
+    )
+    with pytest.raises(FloodModellerAPIError, match=msg):
+        ief.simulate(enginespath=str(tmpdir))
+
+
+def test_simulate_error_without_save():
+    ief = IEF()
+    ief._filepath = None
+    msg = (
+        r"\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+        r"\nAPI Error: Problem encountered when trying to simulate IEF file .*\."
+        r"\n"
+        r"\nDetails: .*-floodmodeller_api/ief\.py-\d+"
+        r"\nMsg: IEF must be saved to a specific filepath before simulate\(\) can be called\."
+        r"\n"
+        r"\nFor additional support, go to: https://github\.com/People-Places-Solutions/floodmodeller-api"
+    )
+    with pytest.raises(FloodModellerAPIError, match=msg):
+        ief.simulate()

floodmodeller_api/test/test_inp.py

@@ -1,48 +1,47 @@
-import os
-from pathlib import Path
-
-import pytest
-
-from floodmodeller_api import INP
-
-
-@pytest.fixture
-def inp_fp(test_workspace):
-    return os.path.join(test_workspace, "network.inp")
-
-
-@pytest.fixture
-def data_before(inp_fp):
-    return INP(inp_fp)._write()
-
-
-def test_inp_open_does_not_change_data(inp_fp, data_before):
-    """INP: Test str representation equal to inp file with no changes"""
-    inp = INP(inp_fp)
-    assert inp._write() == data_before
-
-
-def test_section_name_and_snow_catch_factor_changes(inp_fp, data_before):
-    """INP: Test changing and reverting section name and snow catch factor makes no changes"""
-    inp = INP(inp_fp)
-    prev_name = inp.raingauges["1"].name
-    prev_scf = inp.raingauges["1"].snow_catch_factor
-    inp.raingauges["1"].name = "check"
-    inp.raingauges["1"].snow_catch_factor = 1.5
-    assert inp._write() != data_before
-
-    inp.raingauges["check"].name = prev_name
-    inp.raingauges["check"].snow_catch_factor = prev_scf
-
-    assert inp._write() == data_before
-
-
-def test_all_inp_files_in_folder_have_same_output(test_workspace):
-    """INP: Check all '.inp' files in folder by reading the _write() output into a new INP instance and checking it stays the same."""
-    for inpfile in Path(test_workspace).glob("*.inp"):
-        inp = INP(inpfile)
-        first_output = inp._write()
-        inp.save("__temp.inp")
-        second_output = INP("__temp.inp")._write()
-        assert first_output == second_output
-        os.remove("__temp.inp")
+from pathlib import Path
+
+import pytest
+
+from floodmodeller_api import INP
+
+
+@pytest.fixture
+def inp_fp(test_workspace):
+    return Path(test_workspace, "network.inp")
+
+
+@pytest.fixture
+def data_before(inp_fp):
+    return INP(inp_fp)._write()
+
+
+def test_inp_open_does_not_change_data(inp_fp, data_before):
+    """INP: Test str representation equal to inp file with no changes"""
+    inp = INP(inp_fp)
+    assert inp._write() == data_before
+
+
+def test_section_name_and_snow_catch_factor_changes(inp_fp, data_before):
+    """INP: Test changing and reverting section name and snow catch factor makes no changes"""
+    inp = INP(inp_fp)
+    prev_name = inp.raingauges["1"].name
+    prev_scf = inp.raingauges["1"].snow_catch_factor
+    inp.raingauges["1"].name = "check"
+    inp.raingauges["1"].snow_catch_factor = 1.5
+    assert inp._write() != data_before
+
+    inp.raingauges["check"].name = prev_name
+    inp.raingauges["check"].snow_catch_factor = prev_scf
+
+    assert inp._write() == data_before
+
+
+def test_all_inp_files_in_folder_have_same_output(test_workspace, tmpdir):
+    """INP: Check all '.inp' files in folder by reading the _write() output into a new INP instance and checking it stays the same."""
+    for inpfile in Path(test_workspace).glob("*.inp"):
+        inp = INP(inpfile)
+        first_output = inp._write()
+        new_path = Path(tmpdir) / "tmp.inp"
+        inp.save(new_path)
+        second_output = INP(new_path)._write()
+        assert first_output == second_output

floodmodeller_api/test/test_json.py

@@ -0,0 +1,114 @@
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from floodmodeller_api import DAT, IED, IEF, INP, XML2D
+from floodmodeller_api.to_from_json import is_jsonable
+from floodmodeller_api.util import read_file
+
+
+def create_expected_json_files():
+    """Helper function to recreate all the expected JSON files if needed at any point due to updates
+    to the to_json code"""
+
+    test_workspace = Path(os.path.dirname(__file__), "test_data")
+    for file in [
+        "network.dat",
+        "network.ied",
+        "EX3.DAT",
+        "EX6.DAT",
+        "EX18.DAT",
+        "EX3.IEF",
+        "Domain1_Q.xml",
+        "Linked1D2D.xml",
+    ]:
+        file = Path(test_workspace, file)
+        obj = read_file(file)
+        new_file = file.with_name(f"{file.name.replace('.', '_')}_expected").with_suffix(".json")
+        with open(new_file, "w") as json_file:
+            json_file.write(obj.to_json())
+
+
+@pytest.fixture
+def dat_obj(test_workspace):
+    """JSON:  To create the dat object for the tests"""
+    return DAT(Path(test_workspace, "EX18.DAT"))
+
+
+@pytest.fixture
+def json_expected(test_workspace):
+    """JSON:  expected after passing to_json method"""
+    return Path(test_workspace, "EX18_DAT_expected.json")
+
+
+def test_dat_json(dat_obj):
+    """JSON:  To test if to_json runs without failing"""
+    assert dat_obj.to_json()
+
+
+@pytest.fixture
+def parameterised_objs_and_expected(test_workspace):
+    """JSON:  expected after passing to_json method"""
+    return [
+        (DAT(test_workspace / "EX18.DAT"), test_workspace / "EX18_DAT_expected.json"),
+        (DAT(test_workspace / "network.dat"), test_workspace / "network_dat_expected.json"),
+        (IED(test_workspace / "network.ied"), test_workspace / "network_ied_expected.json"),
+        (DAT(test_workspace / "EX3.DAT"), test_workspace / "EX3_DAT_expected.json"),
+        (DAT(test_workspace / "EX6.DAT"), test_workspace / "EX6_DAT_expected.json"),
+        (IEF(test_workspace / "ex3.ief"), test_workspace / "EX3_IEF_expected.json"),
+        (XML2D(test_workspace / "Domain1_Q.xml"), test_workspace / "Domain1_Q_xml_expected.json"),
+        (XML2D(test_workspace / "Linked1D2D.xml"), test_workspace / "Linked1D2D_xml_expected.json"),
+    ]
+
+
+def test_to_json_matches_expected(parameterised_objs_and_expected):
+    """JSON:  To test if the json object produced in to_json is identical to the expected json file"""
+    for obj, json_expected in parameterised_objs_and_expected:
+        # First, to create and handle the json (str) object
+        # Fetch "Object Attributes" key only as we don't need to compare API versions
+        json_dict_from_obj = json.loads(obj.to_json())["Object Attributes"]
+
+        # Second, to handle the json file ..._expected.json which must be the same as the object created above.
+        json_dict_from_file = json.load(open(json_expected))["Object Attributes"]  # noqa: SIM115
+
+        # keys to ignore when testing for equivalence
+        keys_to_remove = ["_filepath", "file", "_log_path"]
+        for key in keys_to_remove:
+            json_dict_from_obj.pop(key, None)
+            json_dict_from_file.pop(key, None)
+
+        assert json_dict_from_obj == json_dict_from_file
+
+
+@pytest.mark.parametrize(
+    "api_class,file_extension_glob",
+    [
+        (DAT, "*.dat"),
+        (IED, "*.ied"),
+        (XML2D, "*.xml"),
+        (IEF, "*.ief"),
+        (INP, "*.inp"),
+    ],
+)
+def test_obj_reproduces_from_json_for_all_test_api_files(
+    test_workspace,
+    api_class,
+    file_extension_glob,
+):
+    """JSON:  To test the from_json function,  It should produce the same dat file from a json file"""
+    for file in Path(test_workspace).glob(file_extension_glob):
+        assert api_class(file) == api_class.from_json(api_class(file).to_json())
+
+
+def test_is_jsonable_with_jsonable_object():
+    assert is_jsonable({"a": 1, "b": 2})
+
+
+def test_is_jsonable_with_non_jsonable_object():
+    class NonJsonable:
+        def __init__(self):
+            pass
+
+    assert not is_jsonable(NonJsonable())

floodmodeller_api/test/test_logs_lf.py

@@ -1,51 +1,102 @@
-import os
-
-import pandas as pd
-import pytest
-
-from floodmodeller_api import IEF, LF1
-
-
-@pytest.fixture
-def lf1_fp(test_workspace):
-    return os.path.join(test_workspace, "ex3.lf1")
-
-
-def test_lf1_info_dict(lf1_fp):
-    """LF1: Check info dictionary"""
-    lf1 = LF1(lf1_fp)
-    assert lf1.info["version"] == "5.0.0.7752"
-    assert lf1.info["max_system_volume"] == 270549
-    assert lf1.info["mass_balance_error"] == -0.03
-    assert lf1.info["progress"] == 100
-
-
-def test_lf1_report_progress(lf1_fp):
-    """LF1: Check report_progress()"""
-    lf1 = LF1(lf1_fp)
-    assert lf1.report_progress() == 100
-
-
-def test_lf1_to_dataframe(lf1_fp):
-    """LF1: Check to_dataframe()"""
-    lf1 = LF1(lf1_fp)
-    df = lf1.to_dataframe()
-    assert df.iloc[0, 3] == 6
-    assert df.iloc[-1, -1] == 21.06
-    assert df.iloc[4, 0] == -0.07
-
-
-def test_lf1_from_ief(lf1_fp, test_workspace):
-    """LF1: Check IEF.get_lf1()"""
-    lf1 = LF1(lf1_fp)
-
-    ief_fp = os.path.join(test_workspace, "ex3.ief")
-    ief = IEF(ief_fp)
-    lf1_from_ief = ief.get_log()
-
-    assert lf1._filepath == lf1_from_ief._filepath
-    assert lf1.info == lf1_from_ief.info
-    try:
-        pd.testing.assert_frame_equal(lf1.to_dataframe(), lf1_from_ief.to_dataframe())
-    except Exception:
-        pytest.fail("Dataframes not equal")
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pandas as pd
+import pytest
+from freezegun import freeze_time
+
+from floodmodeller_api import IEF, LF1
+from floodmodeller_api.logs import create_lf
+
+
+@pytest.fixture
+def lf1_fp(test_workspace):
+    return Path(test_workspace, "ex3.lf1")
+
+
+def test_lf1_info_dict(lf1_fp):
+    """LF1: Check info dictionary"""
+    lf1 = LF1(lf1_fp)
+    assert lf1.info["version"] == "5.0.0.7752"
+    assert lf1.info["max_system_volume"] == 270549
+    assert lf1.info["mass_balance_error"] == -0.03
+    assert lf1.info["progress"] == 100
+
+
+def test_lf1_report_progress(lf1_fp):
+    """LF1: Check report_progress()"""
+    lf1 = LF1(lf1_fp)
+    assert lf1.report_progress() == 100
+
+
+def test_lf1_to_dataframe(lf1_fp):
+    """LF1: Check to_dataframe()"""
+    lf1 = LF1(lf1_fp)
+    df = lf1.to_dataframe()
+    assert df.loc[df.index[0], "iter"] == 6
+    assert df.loc[df.index[-1], "outflow"] == 21.06
+    assert df.loc[df.index[4], "mass_error"] == -0.07
+
+
+def test_lf1_from_ief(lf1_fp, test_workspace):
+    """LF1: Check IEF.get_lf1()"""
+    lf1 = LF1(lf1_fp)
+
+    ief_fp = Path(test_workspace, "ex3.ief")
+    ief = IEF(ief_fp)
+    lf1_from_ief = ief.get_log()
+
+    assert lf1._filepath == lf1_from_ief._filepath
+    assert lf1.info == lf1_from_ief.info
+    pd.testing.assert_frame_equal(lf1.to_dataframe(), lf1_from_ief.to_dataframe())
+
+
+def test_log_file_unsupported(capsys):
+    lf = create_lf(None, "lf3")
+
+    assert lf is None
+    assert (
+        capsys.readouterr().out
+        == "No progress bar as log file must have suffix lf1 or lf2. Simulation will continue as usual.\n"
+    )
+
+
+@pytest.mark.usefixtures("log_timeout")
+def test_log_file_timeout(capsys):
+    lf_filepath = MagicMock()
+    lf_filepath.is_file.return_value = False
+    lf = create_lf(lf_filepath, "lf1")
+
+    assert lf is None
+    assert (
+        capsys.readouterr().out
+        == "No progress bar as log file is expected but not detected. Simulation will continue as usual.\n"
+    )
+
+
+@pytest.mark.usefixtures("log_timeout")
+@freeze_time("1970-01-01 00:00:00", tick=True)
+def test_log_file_from_old_run(capsys):
+    lf_filepath = MagicMock()
+    lf_filepath.is_file.return_value = True
+    lf_filepath.stat.return_value.st_mtime = -10
+    lf = create_lf(lf_filepath, "lf1")
+
+    assert lf is None
+    assert (
+        capsys.readouterr().out
+        == "No progress bar as log file is from previous run. Simulation will continue as usual.\n"
+    )
+
+
+@pytest.mark.usefixtures("log_timeout")
+@freeze_time("1970-01-01 00:00:00", tick=True)
+def test_log_file_found():
+    lf_filepath = MagicMock()
+    lf_filepath.is_file.return_value = True
+    lf_filepath.stat.return_value.st_mtime = -1
+    with patch("floodmodeller_api.logs.lf.LF1") as lf1:
+        lf = create_lf(lf_filepath, "lf1")
+
+    assert lf is not None
+    lf1.assert_called_once_with(lf_filepath)