Add retrieve result test and correct lock in sqlalchemy

hub/persistence/db_control.py

@@ -114,32 +114,36 @@ class DBControl:
       result_names = []
     results = {}
     for scenario in request_values['scenarios']:
-      scenario_name = next(iter(scenario))
+      print('scenario', scenario, results)
-      result_sets = self._city.get_by_user_id_application_id_and_scenario(
+      for scenario_name in scenario.keys():
-        user_id,
+        print('scenario name', scenario_name)
-        application_id,
-        scenario_name
-      )
-      if result_sets is None:
-        continue
-      for result_set in result_sets:
-        city_id = result_set[0].id
 
-        results[scenario_name] = []
+        result_sets = self._city.get_by_user_id_application_id_and_scenario(
-        for building_name in scenario[scenario_name]:
+          user_id,
-          _building = self._city_object.get_by_name_or_alias_and_city(building_name, city_id)
+          application_id,
-          if _building is None:
+          scenario_name
-            continue
+        )
-          city_object_id = _building.id
+        if result_sets is None:
-          _ = self._simulation_results.get_simulation_results_by_city_id_city_object_id_and_names(
+          continue
-            city_id,
+        for result_set in result_sets:
-            city_object_id,
+          city_id = result_set[0].id
-            result_names)
 
-          for value in _:
+          results[scenario_name] = []
-            values = json.loads(value.values)
+          for building_name in scenario[scenario_name]:
-            values["building"] = building_name
+            _building = self._city_object.get_by_name_or_alias_and_city(building_name, city_id)
-            results[scenario_name].append(values)
+            if _building is None:
+              continue
+            city_object_id = _building.id
+            _ = self._simulation_results.get_simulation_results_by_city_id_city_object_id_and_names(
+              city_id,
+              city_object_id,
+              result_names)
+
+            for value in _:
+              values = json.loads(value.values)
+              values["building"] = building_name
+              results[scenario_name].append(values)
+      print(scenario, results)
     return results
 
   def persist_city(self, city: City, pickle_path, scenario, application_id: int, user_id: int):

hub/persistence/repositories/city.py

@@ -9,6 +9,7 @@ import logging
 
 from sqlalchemy import select
 from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import Session
 
 from hub.city_model_structure.city import City as CityHub
 from hub.persistence.repository import Repository
@@ -111,6 +112,8 @@ class City(Repository):
                                                             Model.application_id == application_id,
                                                             Model.scenario == scenario
                                                             )).all()
+      self.session.close()
+      self.session = Session(self.engine)
       return result_set
     except SQLAlchemyError as err:
       logging.error('Error while fetching city by name %s', err)
@@ -127,6 +130,8 @@ class City(Repository):
       result_set = self.session.execute(
         select(Model).where(Model.user_id == user_id, Model.application_id == application_id)
       )
+      self.session.close()
+      self.session = Session(self.engine)
       return [r[0] for r in result_set]
     except SQLAlchemyError as err:
       logging.error('Error while fetching city by name %s', err)

hub/persistence/repositories/city_object.py

@@ -9,6 +9,7 @@ import logging
 
 from sqlalchemy import select, or_
 from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import Session
 
 from hub.city_model_structure.building import Building
 from hub.persistence.repository import Repository
@@ -108,10 +109,12 @@ class CityObject(Repository):
       city_object = self.session.execute(select(Model).where(Model.name == name, Model.city_id == city_id)).first()
       if city_object is not None:
         return city_object[0]
+      # name not found, so search by alias instead
       city_objects = self.session.execute(
         select(Model).where(Model.aliases.contains(name), Model.city_id == city_id)
       ).all()
-      # name not found, so search by alias instead
+      self.session.close()
+      self.session = Session(self.engine)
       for city_object in city_objects:
         aliases = city_object[0].aliases.replace('{', '').replace('}', '').split(',')
         for alias in aliases:

tests/test_db_retrieve.py

@@ -0,0 +1,152 @@
+"""
+Test db factory
+SPDX - License - Identifier: LGPL - 3.0 - or -later
+Copyright © 2022 Concordia CERC group
+Project Coder Peter Yefi peteryefi@gmail.com
+"""
+import distutils.spawn
+import glob
+import json
+import logging
+import os
+import subprocess
+import unittest
+from pathlib import Path
+from unittest import TestCase
+
+import sqlalchemy.exc
+from sqlalchemy import create_engine
+from sqlalchemy.exc import ProgrammingError
+
+import hub.helpers.constants as cte
+from hub.exports.energy_building_exports_factory import EnergyBuildingsExportsFactory
+from hub.exports.exports_factory import ExportsFactory
+from hub.helpers.data.montreal_function_to_hub_function import MontrealFunctionToHubFunction
+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.imports.weather_factory import WeatherFactory
+from hub.persistence.db_control import DBControl
+from hub.persistence.models import City, Application, CityObject, SimulationResults
+from hub.persistence.models import User, UserRoles
+from hub.persistence.repository import Repository
+
+
+class Control:
+  _skip_test = False
+  _skip_reason = 'PostgreSQL not properly installed in host machine'
+
+  def __init__(self):
+    """
+    Test
+    setup
+    :return: None
+    """
+    self._skip_test = False
+    # Create test database
+    dotenv_path = Path("{}/.local/etc/hub/.env".format(os.path.expanduser('~'))).resolve()
+    if not dotenv_path.exists():
+      self._skip_test = True
+      self._skip_reason = f'.env file missing at {dotenv_path}'
+      return
+    dotenv_path = str(dotenv_path)
+    repository = Repository(db_name='montreal_retrofit_test', app_env='TEST', dotenv_path=dotenv_path)
+    engine = create_engine(repository.configuration.connection_string)
+    try:
+      # delete test database if it exists
+      connection = engine.connect()
+      connection.close()
+    except ProgrammingError:
+      logging.info('Database does not exist. Nothing to delete')
+    except sqlalchemy.exc.OperationalError as operational_error:
+      self._skip_test = True
+      self._skip_reason = f'{operational_error}'
+      return
+
+    self._database = DBControl(
+      db_name=repository.configuration.db_name,
+      app_env='TEST',
+      dotenv_path=dotenv_path)
+
+    self._application_uuid = '60b7fc1b-f389-4254-9ffd-22a4cf32c7a3'
+    self._application_id = 1
+    self._user_id = 1
+    self._pickle_path = 'tests_data/pickle_path.bz2'
+
+  @property
+  def database(self):
+    return self._database
+
+  @property
+  def application_uuid(self):
+    return self._application_uuid
+
+  @property
+  def application_id(self):
+    return self._application_id
+
+  @property
+  def user_id(self):
+    return self._user_id
+
+  @property
+  def skip_test(self):
+    return self._skip_test
+
+  @property
+  def insel(self):
+    return distutils.spawn.find_executable('insel')
+
+  @property
+  def sra(self):
+    return distutils.spawn.find_executable('sra')
+
+  @property
+  def skip_insel_test(self):
+    return self.insel is None
+
+  @property
+  def skip_reason(self):
+    return self._skip_reason
+
+  @property
+  def message(self):
+    return self._skip_reason
+
+  @property
+  def pickle_path(self):
+    return self._pickle_path
+
+
+control = Control()
+
+
+class TestDBFactory(TestCase):
+  """
+TestDBFactory
+"""
+
+  @unittest.skipIf(control.skip_test, control.skip_reason)
+  def test_retrieve_results(self):
+    request_values = {
+      "scenarios": [
+        {
+          "current status": ["01002777", "01002773", "01036804"]
+        },
+        {
+          "skin retrofit": ["01002777", "01002773", "01036804"]
+        },
+        {
+          "system retrofit and pv": ["01002777", "01002773", "01036804"]
+        },
+        {
+          "skin and system retrofit with pv": ["01002777", "01002773", "01036804"]
+        }
+
+
+      ]
+    }
+    results = control.database.results(control.user_id, control.application_id, request_values)
+    print(results)