floodmodeller-api 0.5.0.post1__py3-none-any.whl → 0.5.2__py3-none-any.whl

floodmodeller_api/test/test_logs_lf.py

@@ -1,3 +1,4 @@
+import logging
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
@@ -9,12 +10,12 @@ from floodmodeller_api import IEF, LF1
 from floodmodeller_api.logs import create_lf
 
 
-@pytest.fixture
-def lf1_fp(test_workspace):
+@pytest.fixture()
+def lf1_fp(test_workspace: Path) -> Path:
     return Path(test_workspace, "ex3.lf1")
 
 
-def test_lf1_info_dict(lf1_fp):
+def test_lf1_info_dict(lf1_fp: Path):
     """LF1: Check info dictionary"""
     lf1 = LF1(lf1_fp)
     assert lf1.info["version"] == "5.0.0.7752"
@@ -23,69 +24,89 @@ def test_lf1_info_dict(lf1_fp):
     assert lf1.info["progress"] == 100
 
 
-def test_lf1_report_progress(lf1_fp):
+def test_lf1_report_progress(lf1_fp: Path):
     """LF1: Check report_progress()"""
     lf1 = LF1(lf1_fp)
     assert lf1.report_progress() == 100
 
 
-def test_lf1_to_dataframe(lf1_fp):
+def test_lf1_to_dataframe(lf1_fp: Path):
     """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
+    lf1_df = lf1.to_dataframe(variable="all")
 
+    assert lf1_df.loc[lf1_df.index[0], "iter"] == 6
+    assert lf1.to_dataframe(variable="iter").iloc[0] == 6
 
-def test_lf1_from_ief(lf1_fp, test_workspace):
-    """LF1: Check IEF.get_lf1()"""
+    assert lf1_df.loc[lf1_df.index[-1], "outflow"] == 21.06
+    assert lf1.to_dataframe(variable="outflow").iloc[-1] == 21.06
+
+    assert lf1_df.loc[lf1_df.index[4], "mass_error"] == -0.07
+    assert lf1.to_dataframe(variable="mass_error").iloc[4] == -0.07
+
+    lf1_tuflow_df = lf1.to_dataframe(variable="all", include_tuflow=True)
+    non_tuflow_columns = [col for col in lf1_tuflow_df.columns if "tuflow" not in col]
+    pd.testing.assert_frame_equal(lf1_tuflow_df[non_tuflow_columns], lf1_df)
+
+    tuflow_columns = [col for col in lf1_tuflow_df.columns if "tuflow" in col]
+    expected_tuflow_columns = ["tuflow_vol", "tuflow_n_wet", "tuflow_dt"]
+    assert set(tuflow_columns) == set(expected_tuflow_columns)
+
+    for col in tuflow_columns:
+        assert lf1_tuflow_df[col].isna().all()  # there is no tuflow in this lf1
+
+
+def test_lf1_from_ief(lf1_fp: Path, test_workspace: Path):
+    """LF1: Check IEF.get_log()"""
     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.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")
+def test_log_file_unsupported(caplog):
+    with caplog.at_level(logging.WARNING):
+        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"
+        caplog.text
+        == "WARNING  root:lf.py:325 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")
+def test_log_file_timeout(caplog):
+    with caplog.at_level(logging.WARNING):
+        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"
+        caplog.text
+        == "WARNING  root:lf.py:325 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")
+def test_log_file_from_old_run(caplog):
+    with caplog.at_level(logging.WARNING):
+        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"
+        caplog.text
+        == "WARNING  root:lf.py:325 No progress bar as log file is from previous run. Simulation will continue as usual.\n"
     )
 
 

floodmodeller_api/test/test_read_file.py

@@ -14,6 +14,7 @@ def test_read_file(test_workspace):
                 ".ied",
                 ".xml",
                 ".zzn",
+                ".zzx",
                 ".inp",
                 ".lf1",
                 ".lf2",

floodmodeller_api/test/test_river.py

@@ -54,8 +54,8 @@ river_unit_data_cases = [
 ]
 
 
-@pytest.mark.parametrize(("river_unit_data", "_"), river_unit_data_cases)
-def test_read_write(river_unit_data, _):
+@pytest.mark.parametrize("river_unit_data", [x[0] for x in river_unit_data_cases])
+def test_read_write(river_unit_data):
     river_section_1 = RIVER(river_unit_data)
     river_section_2 = RIVER(river_section_1._write())
     assert river_section_1 == river_section_2
@@ -120,7 +120,7 @@ def test_create_from_blank():
     assert len(blank_unit.data) == 0
     assert len(blank_unit.active_data) == 0
     assert blank_unit._write() == [
-        "RIVER ",
+        "RIVER",
         "SECTION",
         "new_section                                                                         ",
         "     0.000            0.000100  1000.000",
@@ -185,7 +185,7 @@ def test_set_river_dataframe_correct():
         ],
     )
 
-    df = pd.DataFrame(
+    inputs = pd.DataFrame(
         {
             "X": [0.0, 1.0, 2.0],
             "Y": [5.0, 2.0, 5.0],
@@ -200,14 +200,14 @@ def test_set_river_dataframe_correct():
         },
     )
 
-    unit.data = df.copy()
-    pd.testing.assert_frame_equal(unit._data, df.copy())
+    unit.data = inputs.copy()
+    pd.testing.assert_frame_equal(unit._data, inputs.copy())
 
 
 def test_set_river_dataframe_incorrect():
     unit = RIVER()
 
-    df = pd.DataFrame(
+    inputs = pd.DataFrame(
         {
             "X": [0.0, 1.0, 2.0],
             "Y": [5.0, 2.0, 5.0],
@@ -220,14 +220,14 @@ def test_set_river_dataframe_incorrect():
         },
     )
 
-    with pytest.raises(ValueError):
-        unit.data = df.copy()
+    with pytest.raises(ValueError, match="The DataFrame must only contain columns"):
+        unit.data = inputs.copy()
 
 
 def test_set_river_dataframe_case_sensitivity():
     unit = RIVER()
 
-    df = pd.DataFrame(
+    inputs = pd.DataFrame(
         {
             "x": [0.0, 1.0, 2.0],
             "Y": [5.0, 2.0, 5.0],
@@ -242,5 +242,5 @@ def test_set_river_dataframe_case_sensitivity():
         },
     )
 
-    unit.data = df.copy()
-    pd.testing.assert_frame_equal(unit._data, df.copy())
+    unit.data = inputs.copy()
+    pd.testing.assert_frame_equal(unit._data, inputs.copy())

floodmodeller_api/test/test_tool.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import tkinter as tk
 from functools import wraps
+from typing import ClassVar
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -18,7 +21,7 @@ class SumTool(FMTool):
     # Define the name
     name = "Sum tool"
     description = "A basic tool to add two numbers together"
-    parameters = [
+    parameters: ClassVar[list[Parameter]] = [
         Parameter(
             name="a",
             dtype=float,
@@ -37,7 +40,7 @@ class SumTool(FMTool):
     tool_function = my_sum
 
 
-@pytest.fixture
+@pytest.fixture()
 def tool():
     return SumTool()
 
@@ -49,7 +52,7 @@ def test_check_parameters():
         name = ""
         description = ""
         tool_function = print
-        parameters = [
+        parameters: ClassVar[list[Parameter]] = [
             Parameter(
                 name="param1",
                 dtype=str,
@@ -64,7 +67,7 @@ def test_check_parameters():
             ),
         ]
 
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="Parameter names must be unique"):
         MyTool()
 
 
@@ -90,7 +93,7 @@ def test_run_from_command_line():
     class MyTool(FMTool):
         name = "My Tool"
         description = "My Tools Description"
-        parameters = [Parameter("param1", str), Parameter("param2", str)]
+        parameters: ClassVar[list[Parameter]] = [Parameter("param1", str), Parameter("param2", str)]
 
         @classmethod
         def tool_function(cls, param1, param2):

floodmodeller_api/test/test_toolbox_structure_log.py

@@ -1,22 +1,28 @@
 import copy
 import csv
+import json
+import subprocess
 from pathlib import Path
 
 import pandas as pd
 import pytest
 
 from floodmodeller_api import DAT
-from floodmodeller_api.toolbox.model_build.structure_log import StructureLogBuilder
+from floodmodeller_api.toolbox import StructureLog
+from floodmodeller_api.toolbox.model_build.structure_log.structure_log import (
+    StructureLogBuilder,
+    serialise_keys,
+)
 from floodmodeller_api.units.conduits import CONDUIT
 from floodmodeller_api.units.structures import ORIFICE
 
 
-@pytest.fixture
+@pytest.fixture()
 def slb():
     return StructureLogBuilder("", "")
 
 
-@pytest.fixture
+@pytest.fixture()
 def conduit_empty():
     c = CONDUIT()
     c.dist_to_next = 0
@@ -27,6 +33,7 @@ def conduit_empty():
     c.height = 0
     c.width = 0
     c.diameter = 0
+    c.elevation_invert = 0
     c.friction_on_invert = 0
     c.friction_on_soffit = 0
     c.friction_on_walls = 0
@@ -40,7 +47,7 @@ def conduit_empty():
     return c
 
 
-@pytest.fixture
+@pytest.fixture()
 def conduit_filled():
     c = CONDUIT()
     c.dist_to_next = 0
@@ -51,6 +58,7 @@ def conduit_filled():
     c.height = 25.45
     c.width = 3
     c.diameter = 6
+    c.elevation_invert = 3
     c.friction_on_invert = 1.876
     c.friction_on_soffit = 1.34
     c.friction_on_walls = 1.8
@@ -64,171 +72,153 @@ def conduit_filled():
     return c
 
 
-@pytest.fixture
+@pytest.fixture()
 def no_length():
     return 0
 
 
-@pytest.fixture
+@pytest.fixture()
 def with_length():
     return 4.973
 
 
-@pytest.fixture
+@pytest.fixture()
 def structure():
     return ORIFICE()
 
 
-def test_conduit_data(slb, conduit_empty):
-    slb._dat = DAT()
-    output = slb._conduit_data(conduit_empty)
-    assert output == [0.0, "", ""]
-
-
-def test_culvert_loss_data(slb):
-    output = slb._culvert_loss_data("", "")
-    assert output == ""
-    output = slb._culvert_loss_data("TEST1", "TEST2")
-    assert output == "Ki: TEST1, Ko: TEST2"
-
-
-def test_circular_data(slb, conduit_empty, conduit_filled, no_length, with_length):
-    slb._dat = DAT()
-    output = slb._circular_data(conduit_empty, no_length)
-    assert output == ["Mannings: 0", "dia: 0.00 x l: 0.00"]
-    output = slb._circular_data(conduit_filled, with_length)
-    assert output == [
-        "Mannings: [min: 1.453345, max: 3.435]",
-        "dia: 6.00 x l: 4.97",
-    ]
-
-
-def test_sprungarch_data(slb, conduit_empty, conduit_filled, no_length, with_length):
-    output = slb._sprungarch_data(conduit_empty, no_length)
-    assert output == [
-        "Mannings: 0",
-        "(Springing: 0.00, Crown: 0.00) x w: 0.00 x l: 0.00",
-    ]
-    output = slb._sprungarch_data(conduit_filled, with_length)
-    assert output == [
-        "Mannings: [min: 1.34, max: 1.876]",
-        "(Springing: 23.10, Crown: 5.40) x w: 3.00 x l: 4.97",
-    ]
-
-
-def test_rectangular_data(slb, conduit_empty, conduit_filled, no_length, with_length):
-    output = slb._rectangular_data(conduit_empty, no_length)
-    assert output == ["Mannings: 0", "h: 0.00 x w: 0.00 x l: 0.00"]
-    output = slb._rectangular_data(conduit_filled, with_length)
-    assert output == [
-        "Mannings: [min: 1.34, max: 1.876]",
-        "h: 25.45 x w: 3.00 x l: 4.97",
-    ]
-
-
-def test_section_data(slb, conduit_empty, conduit_filled, no_length, with_length):
-    output = slb._section_data(conduit_empty, no_length)
-    assert output == ["Colebrook-White: 0", "h: 0.00 x w: 0.00 x l: 0.00"]
-    output = slb._section_data(conduit_filled, with_length)
-    assert output == [
-        "Colebrook-White: [min: 0.0, max: 4.0]",
-        "h: 65.00 x w: 150.00 x l: 4.97",
-    ]
-
-
-def test_sprung_data(slb, conduit_empty, conduit_filled, no_length, with_length):
-    output = slb._sprung_data(conduit_empty, no_length)
-    assert output == [
-        "Mannings: 0",
-        "(Springing: 0.00, Crown: 0.00) x w: 0.00 x l: 0.00",
-    ]
-    output = slb._sprung_data(conduit_filled, with_length)
-    assert output == [
-        "Mannings: [min: 1.34, max: 1.876]",
-        "(Springing: 23.10, Crown: 5.40) x w: 3.00 x l: 4.97",
-    ]
-
-
-def test_orifice_dimensions(slb, structure):
-    structure.invert = 1
-    output = slb._orifice_dimensions(structure)
-    assert output == "h: -1.00 x w: -1.00"
-
-
-def test_spill_data(slb, structure):
-    structure.data = pd.DataFrame(data={"X": [0, 0], "Y": [0, 0]})
-    structure.weir_coefficient = 0
-    output = slb._spill_data(structure)
-    assert output == ["Elevation: 0.00 x w: 0.00", 0]
-
-
-def test_bridge_data(slb, structure):
-    structure.section_data = pd.DataFrame(data={"X": [0, 0], "Y": [0, 0], "Mannings n": [0, 0]})
-    structure.opening_data = pd.DataFrame(
-        data={"Start": 0, "Finish": 0, "Springing Level": 0, "Soffit Level": 0},
-        index=[0],
-    )
-    output = slb._bridge_data(structure)
-    assert output == ["Mannings: 0", "h: 0.00 x w: 0.00"]
-
-
-def test_add_conduits(slb, conduit_filled, tmpdir):
-    slb._dat = DAT()
-    prev_c = copy.deepcopy(conduit_filled)
-    prev_c.dist_to_next = 0
-    prev_c.name = "prev"
-    slb._dat.conduits["prev"] = prev_c
-    conduit_filled.dist_to_next = 5
-    slb._dat.conduits["test_conduit"] = conduit_filled
-    next_c = copy.deepcopy(conduit_filled)
-    next_c.dist_to_next = 0
-    slb._dat.conduits["next"] = next_c
-    slb._dat._all_units = [prev_c, conduit_filled, next_c]
-    conduit_non_subtype = copy.deepcopy(conduit_filled)
-    conduit_non_subtype._subtype = "NON_SUBTYPE"
-    slb._dat.conduits["test_conduit_NON_SUBTYPE"] = conduit_non_subtype
-
-    tmp_csv = Path(tmpdir) / "temp_structure_data.csv"
-    with tmp_csv.open("w") as file:
+@pytest.fixture()
+def conduit_chain_dat(conduit_filled):
+    dat = DAT()
+    names = ["first", "second", "third", "fourth"]
+    for name in names:
+        cond = copy.deepcopy(conduit_filled)
+        cond.dist_to_next = 10
+        cond.name = name
+        dat.conduits[name] = cond
+        dat._all_units.append(cond)
+
+    cond = copy.deepcopy(conduit_filled)
+    cond.dist_to_next = 0
+    cond.name = "fifth"
+    dat.conduits["fifth"] = cond
+    dat._all_units.append(cond)
+    return dat
+
+
+@pytest.fixture()
+def ex18_dat_path(test_workspace):
+    return Path(test_workspace, "EX18.DAT")
+
+
+@pytest.fixture()
+def ex18_dat_expected():
+    # This is about the limit of what can be pasted in code, if any larger test material is found then read from csv.
+    return """Unit Name,Unit Type,Unit Subtype,Comment,Friction,Dimensions (m),Weir Coefficient,Culvert Inlet/Outlet Loss
+C2,CONDUIT,CIRCULAR,,"Mannings: [min: 0.015, max: 0.020]",dia: 1.00 x l: 100.00 (Total conduit length: 500.00),,Ki: 0.6
+C2_R1,REPLICATE,,,,,,
+C2_R2,REPLICATE,,,,,,
+C2_R3,REPLICATE,,,,,,
+C2_R4,REPLICATE,,,,,,
+C2m,CONDUIT,CIRCULAR,,"Mannings: [min: 0.015, max: 0.020]",dia: 1.00 x l: 0.00,,
+C2md,CONDUIT,CIRCULAR,,"Mannings: [min: 0.015, max: 0.020]",dia: 1.00 x l: 100.00 (Total conduit length: 700.00),,
+C2_R5,REPLICATE,,,,,,
+C2_R6,REPLICATE,,,,,,
+C2_R7,REPLICATE,,,,,,
+C2_R8,REPLICATE,,,,,,
+C2_R9,REPLICATE,,,,,,
+C2_R10,REPLICATE,,,,,,
+C2d,CONDUIT,CIRCULAR,,"Mannings: [min: 0.015, max: 0.020]",dia: 1.00 x l: 0.00,,
+S0,WEIR,,,,Crest Elevation: 21.00 x w: 1.50,,
+C2d,WEIR,,,,Crest Elevation: 18.00 x w: 0.60,,
+S4,WEIR,,,,Crest Elevation: 17.90 x w: 2.00,,
+S8,WEIR,,,,Crest Elevation: 17.70 x w: 2.00,,
+S3LS,SPILL,,,,Elevation: 20.00 x w: 100.00,1.7,
+"""
+
+
+def test_empty_conduit(slb, conduit_empty):
+    slb.dat = DAT()
+    output, _ = slb._conduit_data(conduit_empty)
+    assert output == {
+        "length": 0.0,
+        "total_length": 0.0,
+    }
+
+
+def test_multi_conduits(slb, conduit_chain_dat, tmp_path):
+    expected = """Unit Name,Unit Type,Unit Subtype,Comment,Friction,Dimensions (m),Weir Coefficient,Culvert Inlet/Outlet Loss
+first,CONDUIT,SECTION,,"Colebrook-White: [min: 0.000, max: 4.000]",h: 65.00 x w: 156.00 x l: 10.00 (Total conduit length: 40.00),,
+second,CONDUIT,SECTION,,"Colebrook-White: [min: 0.000, max: 4.000]",h: 65.00 x w: 156.00 x l: 10.00,,
+third,CONDUIT,SECTION,,"Colebrook-White: [min: 0.000, max: 4.000]",h: 65.00 x w: 156.00 x l: 10.00,,
+fourth,CONDUIT,SECTION,,"Colebrook-White: [min: 0.000, max: 4.000]",h: 65.00 x w: 156.00 x l: 10.00,,
+fifth,CONDUIT,SECTION,,"Colebrook-White: [min: 0.000, max: 4.000]",h: 65.00 x w: 156.00 x l: 0.00,,
+"""
+
+    slb.dat = conduit_chain_dat
+    tmp_csv = tmp_path / "test_multi_conduits.csv"
+    with tmp_csv.open("w", newline="") as file:
         slb._writer = csv.writer(file)
-        slb._add_conduits()
-
-
-def test_add_structures(slb, structure, tmpdir):
-    slb._dat = DAT()
-    structure.soffit = 3
-    structure.weir_coefficient = 1
-    structure.data = pd.DataFrame(data={"X": [0, 0], "Y": [0, 0]})
-    structure.section_data = pd.DataFrame(data={"X": [0, 0], "Y": [0, 0], "Mannings n": [0, 0]})
-    structure.opening_data = pd.DataFrame(
-        data={"Start": 0, "Finish": 0, "Springing Level": 0, "Soffit Level": 0},
-        index=[0],
+        slb.add_conduits()
+        slb.write_csv_output(file)
+
+    with open(tmp_csv) as read_file:
+        text = read_file.read()
+
+    assert text == expected
+
+
+@pytest.mark.parametrize(
+    ("filename"),
+    [
+        ("EX18"),
+        ("EX6"),
+        ("EX17"),
+    ],
+)
+def test_multiple_dats(filename, test_workspace, tmp_path):
+    dat_path = Path(test_workspace, f"{filename}.DAT")
+    expected_csv_path = Path(test_workspace / "structure_logs", f"{filename}_expected.csv")
+    expected_json_path = Path(test_workspace / "structure_logs", f"{filename}_expected.json")
+    test_csv_path = tmp_path / f"test_multiple_dats_{filename}.csv"
+    slb = StructureLogBuilder(dat_path, test_csv_path)
+    slb.dat = DAT(slb.dat_file_path)
+    slb.add_conduits()
+    slb.add_structures()
+
+    with expected_json_path.open("r") as file:
+        expected_json_data = json.load(file)
+
+    assert serialise_keys(slb.unit_store) == expected_json_data
+
+    with open(slb.csv_output_path, "w", newline="") as file:
+        slb.write_csv_output(file)
+
+    with expected_csv_path.open("r") as file:
+        expected_csv_data = file.read()
+    with test_csv_path.open("r") as file:
+        test_csv_data = file.read()
+
+    assert test_csv_data == expected_csv_data
+
+
+def test_full_dat_from_python(slb, tmp_path, ex18_dat_path, ex18_dat_expected):
+    # these two tests should be as described in the toolbox documentation
+    tmp_csv = tmp_path / "test_full_dat_from_python.csv"
+    StructureLog.run(input_path=ex18_dat_path, output_path=tmp_csv)
+
+    with open(tmp_csv) as read_file:
+        text = read_file.read()
+    assert text == ex18_dat_expected
+
+
+def test_full_dat_from_commandline(slb, tmp_path, ex18_dat_path, ex18_dat_expected):
+    # these two tests should be as described in the toolbox documentation
+    tmp_csv = tmp_path / "test_full_dat_from_python.csv"
+    subprocess.call(
+        ["fmapi-structure_log", "--input_path", str(ex18_dat_path), "--output_path", str(tmp_csv)],
     )
-    structure.crest_elevation = 1
-    structure.weir_breadth = 1
-    structure.weir_length = 1
-    structure.weir_elevation = 1
-    slb._dat.structures["test_structure_orifice"] = structure
-    struc_spill = copy.deepcopy(structure)
-    struc_spill._unit = "SPILL"
-    slb._dat.structures["test_structure_spill"] = struc_spill
-    struc_sluice = copy.deepcopy(structure)
-    struc_sluice._unit = "SLUICE"
-    slb._dat.structures["test_structure_sluice"] = struc_sluice
-    struc_rnweir = copy.deepcopy(structure)
-    struc_rnweir._unit = "RNWEIR"
-    slb._dat.structures["test_structure_rnweir"] = struc_rnweir
-    struc_weir = copy.deepcopy(structure)
-    struc_weir._unit = "WEIR"
-    slb._dat.structures["test_structure_weir"] = struc_weir
-    struc_bridge = copy.deepcopy(structure)
-    struc_bridge._unit = "BRIDGE"
-    slb._dat.structures["test_structure_bridge"] = struc_bridge
-    struc_none = copy.deepcopy(structure)
-    struc_none._unit = "NONE"
-    slb._dat.structures["test_structure_none"] = struc_none
-
-    tmp_csv = Path(tmpdir) / "temp_structure_data.csv"
-    with tmp_csv.open("w") as file:
-        slb._writer = csv.writer(file)
-        slb._add_structures()
+
+    with open(tmp_csv) as read_file:
+        text = read_file.read()
+    assert text == ex18_dat_expected