Model/recommendations/tests/test_floor_recommendations.py

import pickle
import pytest
import os
from unittest.mock import Mock
from recommendations.FloorRecommendations import FloorRecommendations

# with open(
#     os.path.abspath(os.path.dirname(__file__)) + "/recommendations/tests/test_data/input_properties.pkl", "rb"
# ) as f:
#     input_properties = pickle.load(f)

suspended_floor_insulation_parts = [
    {
        # Example product
        # https://www.insulationsuperstore.co.uk/product/recticel-eurothane-general-purpose-pir-insulation-board-2400
        # -x-1200-x-100mm.html
        # All product data_types here:
        # https://www.insulationsuperstore.co.uk/browse/insulation/brand/recticel/filterby/application/floors.html
        "type": "suspended_floor_insulation",
        "description": "Rigid Insulation Foam Boards",
        "depths": [25, 30, 40, 50, 60, 70, 75, 80, 90, 100, 110, 120, 130, 140, 150],
        "depth_unit": "mm",
        "cost": [25, 30, 40, 50, 60, 70, 75, 80, 90, 100, 110, 120, 130, 140, 150],
        "cost_unit": "gbp_sq_meter",
        "r_value_per_mm": 0.04545454545454546,
        "r_value_unit": "square_meter_kelvin_per_watt",
        "thermal_conductivity": 0.022,
        "thermal_conductivity_unit": "watt_per_meter_kelvin"
    },
    {
        # Example product
        # https://www.insulationsuperstore.co.uk/product/rockwool-rwa45-acoustic-insulation-slab-100mm-2-88m2-pack.html
        # All product data_types here:
        # https://www.insulationsuperstore.co.uk/browse/insulation/brand/rockwool/filterby/application/floors
        # /material/mineral-wool.html
        "type": "suspended_floor_insulation",
        "description": "Mineral Wool Floor Insulation",
        "depths": [25, 40, 50, 60, 75, 100],
        "depth_unit": "mm",
        "cost": [25, 40, 50, 60, 75, 100],
        "cost_unit": "gbp_sq_meter",
        "r_value_per_mm": 0.02857142857142857,
        "r_value_unit": "square_meter_kelvin_per_watt",
        "thermal_conductivity": 0.035,
        "thermal_conductivity_unit": "watt_per_meter_kelvin"
    },
]

solid_floor_insulation_parts = [
    {
        # Example product
        # https://www.insulationexpress.co.uk/floor-insulation/solid-floor-insulation/k103-100mm
        # All product data_types here:
        # https://www.insulationexpress.co.uk/floor-insulation/solid-floor-insulation?brand=7015&p=1
        # Example screed https://www.screwfix.com/p/mapei-ultraplan-3240-self-levelling-compound-25kg/4959f
        "type": "solid_floor_insulation",
        "description": "Rigid Insulation Foam Boards with floor screed",
        "depths": [25, 50, 70, 75, 100],
        "depth_unit": "mm",
        "cost": [25, 40, 50, 60, 75, 100],
        "cost_unit": "gbp_sq_meter",
        "r_value_per_mm": 0.04545454545454546,
        "r_value_unit": "square_meter_kelvin_per_watt",
        "thermal_conductivity": 0.052631578947368425,
        "thermal_conductivity_unit": "watt_per_meter_kelvin"
    },

]

parts = suspended_floor_insulation_parts + solid_floor_insulation_parts


class TestFloorRecommendations:

    @pytest.fixture
    def input_properties(self):
        with open(
            os.path.abspath(os.path.dirname(__file__)) + "/test_data/input_properties.pkl", "rb"
        ) as f:
            return pickle.load(f)

    @pytest.fixture
    def mock_floor_rec_instance(self):
        # Creating a mock instance of WallRecommendations with the necessary attributes
        property_mock = Mock()
        property_mock.full_sap_epc = {"lodgement-date": "2000-01-01"}  # or any date you want
        property_mock.data = {"construction-age-band": "1950"}  # or any other data that fits your tests

        mock_wall_rec_instance = FloorRecommendations(property_mock, parts)
        return mock_wall_rec_instance

    def test_init(self, input_properties):
        obj = FloorRecommendations(
            property_instance=input_properties[0],
            materials=parts
        )
        assert obj
        assert obj.property

    def test_other_premises_below(self, input_properties):
        recommender = FloorRecommendations(
            property_instance=input_properties[0],
            materials=parts
        )
        recommender.recommend()
        assert recommender.property.floor["another_property_below"]

        assert not recommender.recommendations

    def test_suspended_no_insulation(self, input_properties):
        """
        For a suspended floor without insulation, we use the rdsap methogology to estimate a U-value for the floor
        :return:
        """

        input_properties[2].floor_area = 50
        input_properties[2].walls["is_park_home"] = False
        input_properties[2].age_band = "A"
        input_properties[2].perimeter = 20
        input_properties[2].wall_type = "solid brick"

        recommender = FloorRecommendations(
            property_instance=input_properties[2],
            materials=parts
        )
        assert recommender.estimated_u_value is None
        recommender.recommend()
        assert recommender.property.floor["is_suspended"]
        assert recommender.estimated_u_value == 0.39
        assert recommender.recommendations

        types = {part["type"] for x in recommender.recommendations for part in x["parts"]}

        assert types == {"suspended_floor_insulation"}

    def test_uvalue_0_12(self, input_properties):
        """
        This is a home that doesn't have a property below but it's highly performant already and therefore
        does not need floor insulation
        :return:
        """
        recommender = FloorRecommendations(
            property_instance=input_properties[3],
            materials=parts
        )
        assert recommender.estimated_u_value is None
        recommender.recommend()
        assert not recommender.property.floor["is_suspended"]
        assert not recommender.property.floor["is_solid"]
        assert recommender.estimated_u_value is None
        assert not recommender.recommendations

    def test_solid_no_insulation(self, input_properties):
        """
        :return:
        """

        input_properties[4].floor_area = 100
        input_properties[4].walls["is_park_home"] = False
        input_properties[4].age_band = "B"
        input_properties[4].perimeter = 50
        input_properties[4].wall_type = "solid brick"

        recommender = FloorRecommendations(
            property_instance=input_properties[4],
            materials=parts
        )
        assert recommender.estimated_u_value is None
        recommender.recommend()
        assert not recommender.property.floor["is_suspended"]
        assert recommender.property.floor["is_solid"]
        assert recommender.estimated_u_value == 0.71
        assert recommender.recommendations

        types = {part["type"] for x in recommender.recommendations for part in x["parts"]}

        assert types == {"solid_floor_insulation"}

    def test_another_dwelling_below(self, input_properties):
        """
        This is another description we see when there is a property below
        """

        recommender = FloorRecommendations(
            property_instance=input_properties[6],
            materials=parts
        )
        assert recommender.estimated_u_value is None
        recommender.recommend()
        assert not recommender.property.floor["is_suspended"]
        assert not recommender.property.floor["is_solid"]
        assert recommender.estimated_u_value is None
        assert not recommender.recommendations