From 6d4f1ac0a54ebed6883f8f882bb27ffc5c0cef20 Mon Sep 17 00:00:00 2001 From: TheNetworkGuy Date: Tue, 24 Jun 2025 21:28:13 +0200 Subject: [PATCH] Added hostgroup tests --- tests/test_hostgroups.py | 80 +++++++++++----- tests/test_list_hostgroup_formats.py | 137 +++++++++++++++++++++++++++ 2 files changed, 193 insertions(+), 24 deletions(-) create mode 100644 tests/test_list_hostgroup_formats.py diff --git a/tests/test_hostgroups.py b/tests/test_hostgroups.py index 1e652ec..995d26c 100644 --- a/tests/test_hostgroups.py +++ b/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 @@ -334,6 +312,60 @@ class TestHostgroups(unittest.TestCase): calls = [call.write(f"The following options are available for host test-device"), 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__": diff --git a/tests/test_list_hostgroup_formats.py b/tests/test_list_hostgroup_formats.py new file mode 100644 index 0000000..9b8cc21 --- /dev/null +++ b/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()