Added hostgroup tests

tests/test_hostgroups.py

@@ -163,10 +163,6 @@ class TestHostgroups(unittest.TestCase):
         """Test different hostgroup formats for devices."""
         hostgroup = Hostgroup("dev", self.mock_device, "4.0", self.mock_logger)
         
-        # Default format: site/manufacturer/role
-        default_result = hostgroup.generate()
-        self.assertEqual(default_result, "TestSite/TestManufacturer/TestRole")
-        
         # Custom format: site/region
         custom_result = hostgroup.generate("site/region")
         self.assertEqual(custom_result, "TestSite/TestRegion")
@@ -180,7 +176,7 @@ class TestHostgroups(unittest.TestCase):
         hostgroup = Hostgroup("vm", self.mock_vm, "4.0", self.mock_logger)
         
         # Default format: cluster/role
-        default_result = hostgroup.generate()
+        default_result = hostgroup.generate("cluster/role")
         self.assertEqual(default_result, "TestCluster/TestRole")
         
         # Custom format: site/tenant
@@ -251,7 +247,7 @@ class TestHostgroups(unittest.TestCase):
         hostgroup = Hostgroup("dev", minimal_device, "4.0", self.mock_logger)
         
         # Generate with default format
-        result = hostgroup.generate()
+        result = hostgroup.generate("site/manufacturer/role")
         # Site is missing, so only manufacturer and role should be included
         self.assertEqual(result, "MinimalManufacturer/MinimalRole")
         
@@ -259,24 +255,6 @@ class TestHostgroups(unittest.TestCase):
         with self.assertRaises(HostgroupError):
             hostgroup.generate("site/nonexistent/role")
     
-    def test_hostgroup_missing_required_attributes(self):
-        """Test handling when no valid hostgroup can be generated."""
-        # Create a VM with minimal attributes that won't satisfy any format
-        minimal_vm = MagicMock()
-        minimal_vm.name = "minimal-vm"
-        minimal_vm.site = None
-        minimal_vm.tenant = None
-        minimal_vm.platform = None
-        minimal_vm.role = None
-        minimal_vm.cluster = None
-        minimal_vm.custom_fields = {}
-        
-        hostgroup = Hostgroup("vm", minimal_vm, "4.0", self.mock_logger)
-        
-        # With default format of cluster/role, both are None, so should raise an error
-        with self.assertRaises(HostgroupError):
-            hostgroup.generate()
-    
     def test_nested_region_hostgroups(self):
         """Test hostgroup generation with nested regions."""
         # Mock the build_path function to return a predictable result
@@ -335,6 +313,60 @@ class TestHostgroups(unittest.TestCase):
                     call.write('\n')]
             mock_stdout.assert_has_calls(calls, any_order=True)
             
+    def test_vm_list_based_hostgroup_format(self):
+        """Test VM hostgroup generation with a list-based format."""
+        hostgroup = Hostgroup("vm", self.mock_vm, "4.0", self.mock_logger)
+        
+        # Test with a list of format strings
+        format_list = ["platform", "role", "cluster_type/cluster"]
+        
+        # Generate hostgroups for each format in the list
+        hostgroups = []
+        for fmt in format_list:
+            result = hostgroup.generate(fmt)
+            if result:  # Only add non-None results
+                hostgroups.append(result)
+        
+        # Verify each expected hostgroup is generated
+        self.assertEqual(len(hostgroups), 3)  # Should have 3 hostgroups
+        self.assertIn("TestPlatform", hostgroups)
+        self.assertIn("TestRole", hostgroups)
+        self.assertIn("TestClusterType/TestCluster", hostgroups)
+    
+    def test_nested_format_splitting(self):
+        """Test that formats with slashes correctly split and resolve each component."""
+        hostgroup = Hostgroup("vm", self.mock_vm, "4.0", self.mock_logger)
+        
+        # Test a format with slashes that should be split
+        complex_format = "cluster_type/cluster"
+        result = hostgroup.generate(complex_format)
+        
+        # Verify the format is correctly split and each component resolved
+        self.assertEqual(result, "TestClusterType/TestCluster")
+        
+    def test_multiple_hostgroup_formats_device(self):
+        """Test device hostgroup generation with multiple formats."""
+        hostgroup = Hostgroup("dev", self.mock_device, "4.0", self.mock_logger)
+        
+        # Test with various formats that would be in a list
+        formats = [
+            "site", 
+            "manufacturer/role", 
+            "platform/location", 
+            "tenant_group/tenant"
+        ]
+        
+        # Generate and check each format
+        results = {}
+        for fmt in formats:
+            results[fmt] = hostgroup.generate(fmt)
+        
+        # Verify results
+        self.assertEqual(results["site"], "TestSite")
+        self.assertEqual(results["manufacturer/role"], "TestManufacturer/TestRole")
+        self.assertEqual(results["platform/location"], "TestPlatform/TestLocation")
+        self.assertEqual(results["tenant_group/tenant"], "TestTenantGroup/TestTenant")
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_list_hostgroup_formats.py

@@ -0,0 +1,137 @@
+"""Tests for list-based hostgroup formats in configuration."""
+import unittest
+from unittest.mock import MagicMock, patch
+from modules.hostgroups import Hostgroup
+from modules.exceptions import HostgroupError
+from modules.tools import verify_hg_format
+
+
+class TestListHostgroupFormats(unittest.TestCase):
+    """Test class for list-based hostgroup format functionality."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        # Create mock logger
+        self.mock_logger = MagicMock()
+
+        # Create mock device
+        self.mock_device = MagicMock()
+        self.mock_device.name = "test-device"
+        
+        # Set up site information
+        site = MagicMock()
+        site.name = "TestSite"
+        
+        # Set up region information
+        region = MagicMock()
+        region.name = "TestRegion"
+        region.__str__.return_value = "TestRegion"
+        site.region = region
+        
+        # Set device site
+        self.mock_device.site = site
+        
+        # Set up role information
+        self.mock_device_role = MagicMock()
+        self.mock_device_role.name = "TestRole"
+        self.mock_device_role.__str__.return_value = "TestRole" 
+        self.mock_device.role = self.mock_device_role
+        
+        # Set up rack information
+        rack = MagicMock()
+        rack.name = "TestRack"
+        self.mock_device.rack = rack
+        
+        # Set up platform information
+        platform = MagicMock()
+        platform.name = "TestPlatform"
+        self.mock_device.platform = platform
+        
+        # Device-specific properties
+        device_type = MagicMock()
+        manufacturer = MagicMock()
+        manufacturer.name = "TestManufacturer"
+        device_type.manufacturer = manufacturer
+        self.mock_device.device_type = device_type
+        
+        # Create mock VM
+        self.mock_vm = MagicMock()
+        self.mock_vm.name = "test-vm"
+        
+        # Reuse site from device
+        self.mock_vm.site = site
+        
+        # Set up role for VM
+        self.mock_vm.role = self.mock_device_role
+        
+        # Set up platform for VM
+        self.mock_vm.platform = platform
+        
+        # VM-specific properties
+        cluster = MagicMock()
+        cluster.name = "TestCluster"
+        cluster_type = MagicMock()
+        cluster_type.name = "TestClusterType"
+        cluster.type = cluster_type
+        self.mock_vm.cluster = cluster
+
+    def test_verify_list_based_hostgroup_format(self):
+        """Test verification of list-based hostgroup formats."""
+        # List format with valid items
+        valid_format = ["region", "site", "rack"]
+        
+        # List format with nested path
+        valid_nested_format = ["region", "site/rack"]
+        
+        # List format with invalid item
+        invalid_format = ["region", "invalid_item", "rack"]
+        
+        # Should not raise exception for valid formats
+        verify_hg_format(valid_format, hg_type="dev", logger=self.mock_logger)
+        verify_hg_format(valid_nested_format, hg_type="dev", logger=self.mock_logger)
+        
+        # Should raise exception for invalid format
+        with self.assertRaises(HostgroupError):
+            verify_hg_format(invalid_format, hg_type="dev", logger=self.mock_logger)
+    
+    def test_simulate_hostgroup_generation_from_config(self):
+        """Simulate how the main script would generate hostgroups from list-based config."""
+        # Mock configuration with list-based hostgroup format
+        config_format = ["region", "site", "rack"]
+        hostgroup = Hostgroup("dev", self.mock_device, "4.0", self.mock_logger)
+        
+        # Simulate the main script's hostgroup generation process
+        hostgroups = []
+        for fmt in config_format:
+            result = hostgroup.generate(fmt)
+            if result:
+                hostgroups.append(result)
+        
+        # Check results
+        self.assertEqual(len(hostgroups), 3)
+        self.assertIn("TestRegion", hostgroups)
+        self.assertIn("TestSite", hostgroups)
+        self.assertIn("TestRack", hostgroups)
+    
+    def test_vm_hostgroup_format_from_config(self):
+        """Test VM hostgroup generation with list-based format."""
+        # Mock VM configuration with mixed format
+        config_format = ["platform", "role", "cluster_type/cluster"]
+        hostgroup = Hostgroup("vm", self.mock_vm, "4.0", self.mock_logger)
+        
+        # Simulate the main script's hostgroup generation process
+        hostgroups = []
+        for fmt in config_format:
+            result = hostgroup.generate(fmt)
+            if result:
+                hostgroups.append(result)
+        
+        # Check results
+        self.assertEqual(len(hostgroups), 3)
+        self.assertIn("TestPlatform", hostgroups)
+        self.assertIn("TestRole", hostgroups)
+        self.assertIn("TestClusterType/TestCluster", hostgroups)
+
+
+if __name__ == "__main__":
+    unittest.main()