costs/tests/unit_tests.py

import datetime
import glob
import os
import subprocess
import unittest

from pathlib import Path

from hub.exports.energy_building_exports_factory import EnergyBuildingsExportsFactory
from hub.exports.exports_factory import ExportsFactory
from hub.imports.construction_factory import ConstructionFactory
from hub.imports.energy_systems_factory import EnergySystemsFactory
from hub.imports.geometry_factory import GeometryFactory
from hub.imports.results_factory import ResultFactory
from hub.imports.usage_factory import UsageFactory
from hub.helpers.dictionaries import Dictionaries

from costs.cost import Cost
from costs.constants import SKIN_RETROFIT, SKIN_RETROFIT_AND_SYSTEM_RETROFIT_AND_PV, SYSTEM_RETROFIT_AND_PV


class Initialize:
  def __init__(self):
    self._city = None

  @property
  def city(self):
    if self._city is None:
      start = datetime.datetime.now()
      print('init tests')
      city_file = (Path(__file__).parent / 'data/test.geojson').resolve()
      output_path = (Path(__file__).parent / 'output').resolve()
      city = GeometryFactory('geojson',
                             city_file,
                             height_field='citygml_me',
                             year_of_construction_field='ANNEE_CONS',
                             function_field='CODE_UTILI',
                             function_to_hub=Dictionaries().montreal_function_to_hub_function).city
      ConstructionFactory('nrcan', city).enrich()
      UsageFactory('nrcan', city).enrich()
      ExportsFactory('sra', city, output_path).export()
      sra_file = str((output_path / f'{city.name}_sra.xml').resolve())
      subprocess.run(['sra', sra_file], stdout=subprocess.DEVNULL)
      ResultFactory('sra', city, output_path).enrich()
      print(f'sra completed {datetime.datetime.now() - start}')
      for building in city.buildings:
        building.energy_systems_archetype_name = 'system 1 gas pv'
      EnergySystemsFactory('montreal_custom', city).enrich()
      print(f'energy systems completed {datetime.datetime.now() - start}')
      EnergyBuildingsExportsFactory('insel_monthly_energy_balance', city, output_path).export()
      _insel_files = glob.glob(f'{output_path}/*.insel')
      for insel_file in _insel_files:
        subprocess.run(['insel', str(insel_file)], stdout=subprocess.DEVNULL)
      print(f'insel completed {datetime.datetime.now() - start}')
      ResultFactory('insel_monthly_energy_balance', city, output_path).enrich()
      self._city = city
      print(f'init completed {datetime.datetime.now() - start}')
    return self._city


class UnitTests(unittest.TestCase):
  init = Initialize()

  def test_current_status(self):
    for building in self.init.city.buildings:
      result = Cost(building).life_cycle
      self.assertIsNotNone(result)
      self.assertEqual(0, result.values[0])

  def test_scenario_1(self):
    for building in self.init.city.buildings:
      result = Cost(building, retrofit_scenario=SKIN_RETROFIT).life_cycle
      self.assertIsNotNone(result)

  def test_scenario_2(self):
    for building in self.init.city.buildings:
      result = Cost(building, retrofit_scenario=SYSTEM_RETROFIT_AND_PV).life_cycle
      self.assertIsNotNone(result)
      self.assertEqual(0, result.values[0])

  def test_scenario_3(self):
    for building in self.init.city.buildings:
      result = Cost(building, retrofit_scenario=SKIN_RETROFIT_AND_SYSTEM_RETROFIT_AND_PV).life_cycle
      self.assertIsNotNone(result)

  def tearDown(self):
    files = glob.glob('output/[!.]*')
    for file in files:
      os.unlink(file)