tests/test_integration.py

"""
Integration test script for HVAC Load Calculator.
This script tests the integration of all components of the HVAC Load Calculator.
"""

import os
import sys
import json
import unittest
from pathlib import Path

# Add parent directory to path
sys.path.append(str(Path(__file__).parent.parent))

# Import modules
from models.building import Building, CoolingLoadResult
from controllers.enhanced_cooling_load_calculator import calculate_cooling_load
from controllers.monthly_breakdown import calculate_monthly_breakdown, generate_monthly_report
from controllers.building_manager import BuildingManager
from utils.data_io import export_building_to_json, import_building_from_json
from utils.data_io import export_result_to_json, import_result_from_json
from utils.data_io import export_monthly_breakdown_to_csv
from utils.data_io import create_project_archive

class TestIntegration(unittest.TestCase):
    """Integration test cases for HVAC Load Calculator."""
    
    def setUp(self):
        """Set up test fixtures."""
        # Create test buildings
        self.building1 = self._create_test_building("Test Building 1", "New York", 100)
        self.building2 = self._create_test_building("Test Building 2", "Chicago", 150)
        self.building3 = self._create_test_building("Test Building 3", "Los Angeles", 200)
        
        # Create building manager
        self.building_manager = BuildingManager()
        
        # Create test directory
        os.makedirs("test_output", exist_ok=True)
    
    def tearDown(self):
        """Tear down test fixtures."""
        # Remove test files
        for file in os.listdir("test_output"):
            os.remove(os.path.join("test_output", file))
        
        # Remove test directory
        os.rmdir("test_output")
    
    def _create_test_building(self, name, city, area):
        """Create a test building."""
        building = Building()
        building.settings.name = name
        building.settings.floor_area = area
        building.settings.ceiling_height = 3
        building.settings.indoor_temp = 24
        building.settings.indoor_humidity = 50
        
        building.location.city = city
        building.location.latitude = 40.7128
        building.location.longitude = -74.0060
        
        # Add walls
        building.add_wall("North", 10, 3, 0.5, "Medium")
        building.add_wall("South", 10, 3, 0.5, "Medium")
        building.add_wall("East", 10, 3, 0.5, "Medium")
        building.add_wall("West", 10, 3, 0.5, "Medium")
        
        # Add roof
        building.roof.area = area
        building.roof.u_value = 0.3
        building.roof.construction_type = "Medium"
        
        # Add glass
        building.add_glass("North", 2, 1.5, 0.4, 0.8, "Single")
        building.add_glass("South", 2, 1.5, 0.4, 0.8, "Single")
        
        # Add people
        building.people.count = 5
        building.people.activity = "Office Work"
        
        # Add lighting
        building.lighting.power = 500
        building.lighting.type = "LED"
        
        # Add equipment
        building.equipment.power = 1000
        building.equipment.type = "General"
        
        return building
    
    def test_building_manager(self):
        """Test building manager functionality."""
        # Add buildings
        self.assertTrue(self.building_manager.add_building(self.building1))
        self.assertTrue(self.building_manager.add_building(self.building2))
        self.assertTrue(self.building_manager.add_building(self.building3))
        
        # Check buildings
        buildings = self.building_manager.get_buildings()
        self.assertEqual(len(buildings), 3)
        self.assertIn("Test Building 1", buildings)
        self.assertIn("Test Building 2", buildings)
        self.assertIn("Test Building 3", buildings)
        
        # Set current building
        self.building_manager.set_current_building("Test Building 2")
        self.assertEqual(self.building_manager.get_current_building(), "Test Building 2")
        
        # Update building
        self.building2.settings.floor_area = 200
        self.assertTrue(self.building_manager.update_building(self.building2))
        
        # Check updated building
        buildings = self.building_manager.get_buildings()
        self.assertEqual(buildings["Test Building 2"].settings.floor_area, 200)
        
        # Rename building
        self.assertTrue(self.building_manager.rename_building("Test Building 3", "Renamed Building"))
        
        # Check renamed building
        buildings = self.building_manager.get_buildings()
        self.assertNotIn("Test Building 3", buildings)
        self.assertIn("Renamed Building", buildings)
        
        # Duplicate building
        self.assertTrue(self.building_manager.duplicate_building("Test Building 1", "Duplicated Building"))
        
        # Check duplicated building
        buildings = self.building_manager.get_buildings()
        self.assertIn("Duplicated Building", buildings)
        self.assertEqual(buildings["Duplicated Building"].settings.floor_area, 100)
        
        # Calculate building
        result, monthly_breakdown = self.building_manager.calculate_building("Test Building 1")
        
        # Check calculation results
        self.assertIsNotNone(result)
        self.assertIsNotNone(monthly_breakdown)
        
        # Check results in building manager
        results = self.building_manager.get_results()
        monthly_breakdowns = self.building_manager.get_monthly_breakdowns()
        
        self.assertIn("Test Building 1", results)
        self.assertIn("Test Building 1", monthly_breakdowns)
        
        # Remove building
        self.assertTrue(self.building_manager.remove_building("Test Building 1"))
        
        # Check removed building
        buildings = self.building_manager.get_buildings()
        self.assertNotIn("Test Building 1", buildings)
        
        # Check removed results
        results = self.building_manager.get_results()
        monthly_breakdowns = self.building_manager.get_monthly_breakdowns()
        
        self.assertNotIn("Test Building 1", results)
        self.assertNotIn("Test Building 1", monthly_breakdowns)
    
    def test_end_to_end_workflow(self):
        """Test end-to-end workflow."""
        # 1. Create buildings
        building1 = self._create_test_building("Office Building", "New York", 1000)
        building2 = self._create_test_building("Retail Building", "Chicago", 1500)
        
        # 2. Calculate cooling loads
        result1 = calculate_cooling_load(building1)
        result2 = calculate_cooling_load(building2)
        
        # 3. Calculate monthly breakdowns
        monthly_breakdown1 = calculate_monthly_breakdown(building1)
        monthly_breakdown2 = calculate_monthly_breakdown(building2)
        
        # 4. Generate monthly reports
        report1 = generate_monthly_report(building1, monthly_breakdown1)
        report2 = generate_monthly_report(building2, monthly_breakdown2)
        
        # 5. Export buildings to JSON
        json_str1 = export_building_to_json(building1)
        json_str2 = export_building_to_json(building2)
        
        # 6. Save JSON to files
        with open(os.path.join("test_output", "building1.json"), "w") as f:
            f.write(json_str1)
        
        with open(os.path.join("test_output", "building2.json"), "w") as f:
            f.write(json_str2)
        
        # 7. Import buildings from JSON
        imported_building1 = import_building_from_json(json_str1)
        imported_building2 = import_building_from_json(json_str2)
        
        # 8. Calculate cooling loads for imported buildings
        imported_result1 = calculate_cooling_load(imported_building1)
        imported_result2 = calculate_cooling_load(imported_building2)
        
        # 9. Compare original and imported results
        self.assertEqual(result1.peak_total_load, imported_result1.peak_total_load)
        self.assertEqual(result2.peak_total_load, imported_result2.peak_total_load)
        
        # 10. Create project archives
        archive1 = create_project_archive(building1, result1, monthly_breakdown1)
        archive2 = create_project_archive(building2, result2, monthly_breakdown2)
        
        # 11. Save archives to files
        with open(os.path.join("test_output", "project1.zip"), "wb") as f:
            f.write(archive1)
        
        with open(os.path.join("test_output", "project2.zip"), "wb") as f:
            f.write(archive2)
        
        # 12. Check files exist
        self.assertTrue(os.path.exists(os.path.join("test_output", "building1.json")))
        self.assertTrue(os.path.exists(os.path.join("test_output", "building2.json")))
        self.assertTrue(os.path.exists(os.path.join("test_output", "project1.zip")))
        self.assertTrue(os.path.exists(os.path.join("test_output", "project2.zip")))
        
        # 13. Add buildings to building manager
        building_manager = BuildingManager()
        building_manager.add_building(building1)
        building_manager.add_building(building2)
        
        # 14. Check buildings in building manager
        buildings = building_manager.get_buildings()
        self.assertEqual(len(buildings), 2)
        self.assertIn("Office Building", buildings)
        self.assertIn("Retail Building", buildings)

if __name__ == "__main__":
    unittest.main()