Add final tests

Author: H0R5E

packages/dtocean-economics/src/dtocean_economics/__init__.py

@@ -70,8 +70,8 @@ def get_phase_breakdown(bom: pd.DataFrame):
     phase_groups = bom.groupby("phase")
 
     phase_breakdown = phase_groups.sum()
-    if "unitary_costs" in phase_breakdown:
-        phase_breakdown.drop("unitary_costs", axis=1, inplace=True)
+    if "unitary_cost" in phase_breakdown:
+        phase_breakdown.drop("unitary_cost", axis=1, inplace=True)
 
     return phase_breakdown
 

packages/dtocean-economics/src/dtocean_economics/preprocessing.py

@@ -27,21 +27,14 @@
 def estimate_cost_per_power(total_rated_power, unit_cost, phase=None):
     cost = total_rated_power * unit_cost
     cost_bom = make_phase_bom([1], [cost], [0], phase)
-
     return cost_bom
 
 
-def estimate_energy(lifetime, year_energy, network_efficiency=None):
-    if network_efficiency is not None:
-        net_coeff = network_efficiency
-    else:
-        net_coeff = 1.0
-
-    energy = [0] + [year_energy * net_coeff] * lifetime
+def estimate_energy(lifetime, year_energy, network_efficiency=1.0):
+    energy = [0] + [year_energy * network_efficiency] * lifetime
     energy_year = range(lifetime + 1)
 
     raw_energy = {"energy": energy, "project_year": energy_year}
-
     energy_record = pd.DataFrame(raw_energy)
 
     return energy_record

packages/dtocean-economics/src/dtocean_plugins/themes/economics.py

@@ -517,7 +517,7 @@ def _get_outputs(
     externalities_opex: Optional[float],
 ) -> dict[str, Any]:
     series = [opex_bom, energy_record]
-    series_lengths = [len(x) for x in series if not x.empty]
+    series_lengths = [len(x.columns) for x in series if not x.empty]
     if len(series_lengths) == 2 and len(set(series_lengths)) != 1:
         msg = "opex bom and energy record must be the same length if not empty"
         raise ValueError(msg)
@@ -900,23 +900,7 @@ def _get_outputs_stats(
         except np.linalg.LinAlgError:
             _get_discounted_opex_stats(outputs, discounted_opex)
             _get_discounted_energy_stats(outputs, discounted_energy)
-
-            assert lcoe_total is not None
-
-            # Euro/Wh to Euro/kWh
-            try:
-                distribution = UniVariateKDE(lcoe_total)
-                outputs["lcoe_mean"] = distribution.mean() * 1000
-                outputs["lcoe_mode"] = distribution.mode() * 1000
-
-                intervals = distribution.confidence_interval(95)
-
-                if intervals is not None:
-                    outputs["lcoe_lower"] = intervals[0] * 1000
-                    outputs["lcoe_upper"] = intervals[1] * 1000
-
-            except np.linalg.LinAlgError:
-                outputs["lcoe_mean"] = lcoe_total.mean() * 1000
+            _get_lcoe_stats(outputs, lcoe_total)
 
         return outputs
 
@@ -926,6 +910,9 @@ def _get_outputs_stats(
     if discounted_energy is not None:
         _get_discounted_energy_stats(outputs, discounted_energy)
 
+    if lcoe_total is not None:
+        _get_lcoe_stats(outputs, lcoe_total)
+
     return outputs
 
 
@@ -962,6 +949,23 @@ def _get_discounted_energy_stats(outputs: dict[str, Any], discounted_energy):
         outputs["discounted_energy_mean"] = discounted_energy.mean() / 1e6
 
 
+def _get_lcoe_stats(outputs: dict[str, Any], lcoe_total):
+    # Euro/Wh to Euro/kWh
+    try:
+        distribution = UniVariateKDE(lcoe_total)
+        outputs["lcoe_mean"] = distribution.mean() * 1000
+        outputs["lcoe_mode"] = distribution.mode() * 1000
+
+        intervals = distribution.confidence_interval(95)
+
+        if intervals is not None:
+            outputs["lcoe_lower"] = intervals[0] * 1000
+            outputs["lcoe_upper"] = intervals[1] * 1000
+
+    except np.linalg.LinAlgError:
+        outputs["lcoe_mean"] = lcoe_total.mean() * 1000
+
+
 def _get_opex_breakdown(
     opex_bom,
     externalities_opex,

packages/dtocean-economics/tests/dtocean_economics/test_functions.py

@@ -85,6 +85,8 @@ def test_get_phase_breakdown(bom):
     assert isinstance(other, pd.Series)
     assert other["costs"] == 364
 
+    assert "unitary_cost" not in result
+
 
 def test_get_phase_breakdown_none(bom):
     none_bom = bom[pd.isnull(bom["phase"])]
@@ -93,6 +95,11 @@ def test_get_phase_breakdown_none(bom):
     assert result is None
 
 
+def test_get_phase_breakdown_no_costs():
+    result = get_phase_breakdown(pd.DataFrame())
+    assert result is None
+
+
 def test_get_present_values():
     value = np.array([1, 6 / 5, 36 / 25, 216 / 125])
     year = np.array([0, 1, 2, 3])

packages/dtocean-economics/tests/dtocean_plugins/themes/test_themes_economics.py

@@ -1533,3 +1533,102 @@ def test_get_outputs_8_UniVariateKDE_error(
         abs(outputs["lcoe_mean"] - lcoe_expected) / lcoe_expected * 100
     )
     assert lcoe_mean_error < 20
+
+
+def test_get_outputs_8_no_opex(
+    bom,
+    energy_record_8,
+):
+    discount_rate = 1 / 5
+    outputs = _get_outputs(
+        bom,
+        pd.DataFrame(),
+        energy_record_8,
+        discount_rate,
+        1e6,
+        None,
+    )
+
+    none_outputs = [
+        "discounted_opex_lower",
+        "discounted_opex_mean",
+        "discounted_opex_mode",
+        "discounted_opex_upper",
+        "lifetime_cost_mode",
+        "discounted_lifetime_cost_mode",
+        "lifetime_opex_mean",
+        "lifetime_opex_mode",
+        "lifetime_opex_lower",
+        "lifetime_opex_upper",
+        "confidence_density",
+        "lcoe_pdf",
+        "opex_breakdown",
+        "opex_lcoe_breakdown",
+    ]
+    for key in none_outputs:
+        if outputs[key] is not None:
+            print(key)
+        assert outputs[key] is None
+
+    non_none_outputs = set(outputs.keys()) - set(none_outputs)
+    for key in non_none_outputs:
+        if outputs[key] is None:
+            print(key)
+        assert outputs[key] is not None
+
+
+def test_get_outputs_8_no_energy(
+    bom,
+    opex_costs_8,
+):
+    discount_rate = 1 / 5
+    outputs = _get_outputs(
+        bom,
+        opex_costs_8,
+        pd.DataFrame(),
+        discount_rate,
+        1e6,
+        None,
+    )
+
+    none_outputs = [
+        "opex_breakdown",
+        "discounted_energy_lower",
+        "discounted_energy_mean",
+        "discounted_energy_mode",
+        "discounted_energy_upper",
+        "lcoe_mean",
+        "lcoe_mode",
+        "lcoe_lower",
+        "lcoe_upper",
+        "confidence_density",
+        "lcoe_pdf",
+        "lcoe_breakdown",
+        "opex_lcoe_breakdown",
+        "capex_lcoe_breakdown",
+    ]
+    for key in none_outputs:
+        if outputs[key] is not None:
+            print(key)
+        assert outputs[key] is None
+
+    non_none_outputs = set(outputs.keys()) - set(none_outputs)
+    for key in non_none_outputs:
+        if outputs[key] is None:
+            print(key)
+        assert outputs[key] is not None
+
+
+def test_get_outputs_non_matching(bom, opex_costs_8, energy_record_0):
+    with pytest.raises(ValueError) as exc:
+        discount_rate = 1 / 5
+        _get_outputs(
+            bom,
+            opex_costs_8,
+            energy_record_0,
+            discount_rate,
+            1e6,
+            None,
+        )
+
+    assert "must be the same length" in str(exc)