1# -*- coding: utf-8 -*- 2 3# 4# Dell EMC OpenManage Ansible Modules 5# Version 2.1.1 6# Copyright (C) 2019-2020 Dell Inc. or its subsidiaries. All Rights Reserved. 7 8# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) 9# 10 11from __future__ import (absolute_import, division, print_function) 12__metaclass__ = type 13 14import json 15import pytest 16from io import StringIO 17from ssl import SSLError 18from ansible.module_utils.six.moves.urllib.error import HTTPError, URLError 19from ansible.module_utils.urls import ConnectionError, SSLValidationError 20from ansible.module_utils._text import to_text 21from ansible_collections.dellemc.openmanage.plugins.modules import ome_application_network_address 22from ansible_collections.dellemc.openmanage.tests.unit.plugins.modules.common import FakeAnsibleModule, Constants 23 24MODULE_PATH = 'ansible_collections.dellemc.openmanage.plugins.modules.' 25 26 27@pytest.fixture 28def ome_connection_mock_for_application_network_address(mocker, ome_response_mock): 29 connection_class_mock = mocker.patch(MODULE_PATH + 'ome_application_network_address.RestOME') 30 ome_connection_mock_obj = connection_class_mock.return_value.__enter__.return_value 31 ome_connection_mock_obj.invoke_request.return_value = ome_response_mock 32 return ome_connection_mock_obj 33 34 35class TestOmeAppNetwork(FakeAnsibleModule): 36 module = ome_application_network_address 37 38 inp_param = { 39 "hostname": "192.1.2.3", 40 "password": "password", 41 "port": 443, 42 "username": "root", 43 "enable_nic": True, 44 "interface_name": "eth0", 45 "dns_configuration": {"dns_domain_name": "localdomain", "dns_name": "openmanage-enterprise", 46 "register_with_dns": False, 47 "use_dhcp_for_dns_domain_name": False}, 48 "ipv4_configuration": {"enable": True, "enable_dhcp": True, "use_dhcp_for_dns_server_names": True, 49 "static_ip_address": "192.168.11.20", "static_subnet_mask": "255.255.255.0", 50 "static_gateway": "192.168.11.1", "static_preferred_dns_server": "192.168.11.2", 51 "static_alternate_dns_server": "192.168.11.3"}, 52 "ipv6_configuration": {"enable": True, "enable_auto_configuration": True, 53 "static_alternate_dns_server": "2607:f2b1:f081:9:1c8c:f1c7:47e:f121", 54 "static_gateway": "0000::ffff", 55 "static_ip_address": "2607:f2b1:f081:9:1c8c:f1c7:47e:f120", 56 "static_preferred_dns_server": "2607:f2b1:f081:9:1c8c:f1c7:47e:f122", 57 "static_prefix_length": 0, "use_dhcp_for_dns_server_names": True}, 58 "management_vlan": {"enable_vlan": False, "vlan_id": 0}, 59 "reboot_delay": 1} 60 inp_param1 = { 61 "hostname": "192.1.2.3", 62 "password": "password", 63 "port": 443, 64 "username": "root", 65 "enable_nic": False 66 } 67 out_param = {"EnableNIC": False, 68 "InterfaceName": "eth0", 69 "PrimaryInterface": True, 70 "Ipv4Configuration": {"Enable": True, "EnableDHCP": True, "StaticIPAddress": "192.168.11.20", 71 "StaticSubnetMask": "255.255.255.0", "StaticGateway": "192.168.11.1", 72 "UseDHCPForDNSServerNames": True, "StaticPreferredDNSServer": "192.168.11.2", 73 "StaticAlternateDNSServer": "192.168.11.3"}, 74 "Ipv6Configuration": {"Enable": True, "EnableAutoConfiguration": True, 75 "StaticIPAddress": "2607:f2b1:f081:9:1c8c:f1c7:47e:f120", 76 "StaticPrefixLength": 0, "StaticGateway": "0000::ffff", 77 "UseDHCPForDNSServerNames": True, 78 "StaticPreferredDNSServer": "2607:f2b1:f081:9:1c8c:f1c7:47e:f122", 79 "StaticAlternateDNSServer": "2607:f2b1:f081:9:1c8c:f1c7:47e:f121"}, 80 "ManagementVLAN": {"EnableVLAN": False, "Id": 0}, 81 "DnsConfiguration": {"RegisterWithDNS": False, "DnsName": "openmanage-enterprise", 82 "UseDHCPForDNSDomainName": False, "DnsDomainName": "localdomain"}, 83 "Delay": 0 84 } 85 86 @pytest.mark.parametrize("addr_param", [{"in": inp_param, "out": out_param}, 87 {"in": inp_param1, "out": out_param}]) 88 def test_ome_application_network_address_main_success_case_01(self, mocker, ome_default_args, addr_param, 89 ome_connection_mock_for_application_network_address, 90 ome_response_mock): 91 IP_CONFIG = "ApplicationService/Network/AddressConfiguration" 92 JOB_IP_CONFIG = "ApplicationService/Network/AdapterConfigurations" 93 POST_IP_CONFIG = "ApplicationService/Actions/Network.ConfigureNetworkAdapter" 94 ome_default_args.update(addr_param["in"]) 95 ipv4 = {"Enable": True, "EnableDHCP": True, "StaticIPAddress": "192.168.11.20", 96 "StaticSubnetMask": "255.255.255.0", "StaticGateway": "192.168.11.1", 97 "UseDHCPForDNSServerNames": True, "StaticPreferredDNSServer": "192.168.11.1", 98 "StaticAlternateDNSServer": ""} 99 ipv6 = {"Enable": False, "EnableAutoConfiguration": True, "StaticIPAddress": "", 100 "StaticPrefixLength": 0, "StaticGateway": "", "UseDHCPForDNSServerNames": True, 101 "StaticPreferredDNSServer": "", "StaticAlternateDNSServer": ""} 102 dns = {"RegisterWithDNS": False, "DnsName": "openmanage-enterprise", 103 "UseDHCPForDNSDomainName": False, "DnsDomainName": "localdomain"} 104 vlan = {"EnableVLAN": False, "Id": 1} 105 mocker.patch(MODULE_PATH + "ome_application_network_address.validate_input") 106 mocker.patch(MODULE_PATH + "ome_application_network_address.get_payload", 107 return_value=(ipv4, ipv6, dns, vlan)) 108 mocker.patch(MODULE_PATH + "ome_application_network_address.get_updated_payload", 109 return_value=(addr_param["out"], "PUT", IP_CONFIG)) 110 ome_response_mock.json_data = addr_param["out"] 111 ome_response_mock.success = True 112 mresult = self.execute_module(ome_default_args) 113 assert mresult['changed'] is True 114 assert "msg" in mresult 115 assert "network_configuration" in mresult and mresult["network_configuration"] == addr_param["out"] 116 assert mresult["msg"] == "Successfully triggered task to update network address configuration." 117 118 @pytest.mark.parametrize("addr_param", [{"in": inp_param, "out": out_param}]) 119 def test_ome_application_network_address_main_success_case_02(self, mocker, ome_default_args, addr_param, 120 ome_connection_mock_for_application_network_address, 121 ome_response_mock): 122 POST_IP_CONFIG = "ApplicationService/Actions/Network.ConfigureNetworkAdapter" 123 ome_default_args.update(addr_param["in"]) 124 ipv4 = {"Enable": True, "EnableDHCP": True, "StaticIPAddress": "192.168.11.20", 125 "StaticSubnetMask": "255.255.255.0", "StaticGateway": "192.168.11.1", 126 "UseDHCPForDNSServerNames": True, "StaticPreferredDNSServer": "192.168.11.1", 127 "StaticAlternateDNSServer": ""} 128 ipv6 = {"Enable": False, "EnableAutoConfiguration": True, "StaticIPAddress": "", 129 "StaticPrefixLength": 0, "StaticGateway": "", "UseDHCPForDNSServerNames": True, 130 "StaticPreferredDNSServer": "", "StaticAlternateDNSServer": ""} 131 dns = {"RegisterWithDNS": False, "DnsName": "openmanage-enterprise", 132 "UseDHCPForDNSDomainName": False, "DnsDomainName": "localdomain"} 133 vlan = {"EnableVLAN": False, "Id": 1} 134 mocker.patch(MODULE_PATH + "ome_application_network_address.validate_input") 135 mocker.patch(MODULE_PATH + "ome_application_network_address.get_payload", 136 return_value=(ipv4, ipv6, dns, vlan)) 137 mocker.patch(MODULE_PATH + "ome_application_network_address.get_updated_payload", 138 return_value=(addr_param["out"], "POST", POST_IP_CONFIG)) 139 ome_response_mock.json_data = addr_param["out"] 140 ome_response_mock.success = True 141 mresult = self.execute_module(ome_default_args) 142 assert mresult['changed'] is True 143 assert "msg" in mresult 144 assert "network_configuration" in mresult and mresult["network_configuration"] == addr_param["out"] 145 assert mresult["msg"] == "Successfully triggered job to update network address configuration." 146 147 @pytest.mark.parametrize("addr_param", [{"in": inp_param, "out": out_param}]) 148 def test_get_payload(self, addr_param, ome_default_args): 149 ome_default_args.update(addr_param["in"]) 150 f_module = self.get_module_mock(params=addr_param["in"]) 151 ipv4_payload, ipv6_payload, dns_payload, vlan_payload = self.module.get_payload(f_module) 152 assert ipv4_payload == addr_param["out"]["Ipv4Configuration"] 153 assert ipv6_payload == addr_param["out"]["Ipv6Configuration"] 154 assert dns_payload == addr_param["out"]["DnsConfiguration"] 155 assert vlan_payload == addr_param["out"]["ManagementVLAN"] 156 157 @pytest.mark.parametrize("addr_param", [{"in": inp_param, "out": out_param}]) 158 def test_get_updated_payload(self, mocker, ome_default_args, addr_param, 159 ome_connection_mock_for_application_network_address, 160 ome_response_mock): 161 ome_default_args.update(addr_param["in"]) 162 f_module = self.get_module_mock(params=addr_param["in"]) 163 ome_response_mock.json_data = {"value": [addr_param["out"]]} 164 ipv4 = {"Enable": True, "EnableDHCP": True, "StaticIPAddress": "192.168.11.20", 165 "StaticSubnetMask": "255.255.255.0", "StaticGateway": "192.168.11.1", 166 "UseDHCPForDNSServerNames": True, "StaticPreferredDNSServer": "192.168.11.2", 167 "StaticAlternateDNSServer": "192.168.11.3"} 168 ipv6 = {"Enable": True, "EnableAutoConfiguration": False, 169 "StaticIPAddress": "2607:f2b1:f081:9:1c8c:f1c7:47e:f12", 170 "StaticPrefixLength": 0, "StaticGateway": "0000::ffff", "UseDHCPForDNSServerNames": True, 171 "StaticPreferredDNSServer": "2607:f2b1:f081:9:1c8c:f1c7:47e:f122", 172 "StaticAlternateDNSServer": "2607:f2b1:f081:9:1c8c:f1c7:47e:f12"} 173 dns = {"RegisterWithDNS": False, "DnsName": "openmanage-enterprise", 174 "UseDHCPForDNSDomainName": False, "DnsDomainName": "localdomain"} 175 vlan = {"EnableVLAN": False, "Id": 1} 176 current_setting, method, uri = self.module.get_updated_payload( 177 ome_connection_mock_for_application_network_address, f_module, ipv4, ipv6, dns, vlan) 178 assert current_setting == addr_param["out"] 179 180 def test_get_updated_payload_when_same_setting_failure_case(self, ome_default_args, 181 ome_connection_mock_for_application_network_address, 182 ome_response_mock): 183 ipv4 = {"Enable": True, "EnableDHCP": True, "StaticIPAddress": "192.168.11.20", 184 "StaticSubnetMask": "255.255.255.0", "StaticGateway": "192.168.11.1", 185 "UseDHCPForDNSServerNames": True, "StaticPreferredDNSServer": "192.168.11.2", 186 "StaticAlternateDNSServer": "192.168.11.3"} 187 ipv6 = {"Enable": True, "EnableAutoConfiguration": True, 188 "StaticIPAddress": "2607:f2b1:f081:9:1c8c:f1c7:47e:f120", 189 "StaticPrefixLength": 0, "StaticGateway": "0000::ffff", "UseDHCPForDNSServerNames": True, 190 "StaticPreferredDNSServer": "2607:f2b1:f081:9:1c8c:f1c7:47e:f122", 191 "StaticAlternateDNSServer": "2607:f2b1:f081:9:1c8c:f1c7:47e:f121"} 192 dns = {"RegisterWithDNS": False, "DnsName": "openmanage-enterprise", 193 "UseDHCPForDNSDomainName": False, "DnsDomainName": "localdomain"} 194 vlan = {"EnableVLAN": False, "Id": 1} 195 current_setting = {"value": [{ 196 "@odata.context": "/api/$metadata#Network.AddressConfiguration/$entity", 197 "@odata.type": "#Network.AddressConfiguration", 198 "@odata.id": "/api/ApplicationService/Network/AddressConfiguration", 199 "EnableNIC": True, 200 "InterfaceName": "eth0", 201 "PrimaryInterface": True, 202 "Ipv4Configuration": ipv4, 203 "Ipv6Configuration": ipv6, 204 "DnsConfiguration": dns, 205 "ManagementVLAN": vlan, 206 "Delay": 0 207 }]} 208 ome_default_args.update({"enable_nic": True, "interface_name": "eth0"}) 209 f_module = self.get_module_mock(params=ome_default_args) 210 ome_response_mock.json_data = current_setting 211 error_message = "No changes made to network configuration as entered values are the same as current configured values" 212 with pytest.raises(Exception, match=error_message) as err: 213 self.module.get_updated_payload(ome_connection_mock_for_application_network_address, f_module, ipv4, ipv6, 214 dns, vlan) 215 216 @pytest.mark.parametrize("addr_param", 217 [{"in": inp_param["ipv4_configuration"], "out": out_param["Ipv4Configuration"]}, 218 {"in": {"enable": True, "enable_auto_configuration": True, 219 "static_alternate_dns_server": "2607:f2b1:f081:9:1c8c:f1c7:47e:f121", 220 "static_gateway": "0000::ffff", 221 "static_ip_address": "2607:f2b1:f081:9:1c8c:f1c7:47e:f120", 222 "static_preferred_dns_server": "2607:f2b1:f081:9:1c8c:f1c7:47e:f122", 223 "static_prefix_length": 0, "use_dhcp_for_dns_server_names": True}, 224 "out": {"Enable": True, "EnableAutoConfiguration": True, 225 "StaticIPAddress": "2607:f2b1:f081:9:1c8c:f1c7:47e:f120", 226 "StaticPrefixLength": 0, "StaticGateway": "0000::ffff", 227 "UseDHCPForDNSServerNames": True, 228 "StaticPreferredDNSServer": "2607:f2b1:f081:9:1c8c:f1c7:47e:f122", 229 "StaticAlternateDNSServer": "2607:f2b1:f081:9:1c8c:f1c7:47e:f121"}}, 230 {"in": inp_param["dns_configuration"], "out": out_param["DnsConfiguration"]}, 231 {"in": None, "out": None}]) 232 def test_format_payload(self, addr_param): 233 result = self.module.format_payload(addr_param["in"]) 234 assert result == addr_param["out"] 235 236 @pytest.mark.parametrize("addr_param", [{"in": inp_param}, 237 {"in": {"dns_configuration": {"register_with_dns": True}}}, 238 {"in": {"management_vlan": {"enable_vlan": True}}} 239 ]) 240 def test_validate_input_success(self, addr_param): 241 f_module = self.get_module_mock(params=addr_param["in"]) 242 self.module.validate_input(f_module) 243 244 def _test_validate_input_fail1(self, ome_default_args): 245 ome_default_args.update( 246 {"management_vlan": {"enable_vlan": True}, "dns_configuration": {"register_with_dns": True}}) 247 f_module = self.get_module_mock(params=ome_default_args) 248 error_message = "The vLAN settings cannot be updated if the 'register_with_dns' is true. " \ 249 "The 'register_with_dns' cannot be updated if vLAN settings change." 250 with pytest.raises(Exception, match=error_message) as err: 251 self.module.validate_input(f_module) 252 253 def test_validate_input_fail2(self, ome_default_args): 254 ome_default_args.update({"reboot_delay": -1}) 255 f_module = self.get_module_mock(params=ome_default_args) 256 error_message = "Invalid value provided for 'reboot_delay'" 257 with pytest.raises(Exception, match=error_message) as err: 258 self.module.validate_input(f_module) 259 260 @pytest.mark.parametrize("addr_param", [{"in": "192.168.0.5", "out": True}, 261 {"in": "2607:f2b1:f081:9:1c8c:f1c7:47e:f121", "out": False}]) 262 def test_validate_ip_address(self, addr_param): 263 ret_val = self.module.validate_ip_address(addr_param["in"]) 264 assert ret_val == addr_param["out"] 265 266 @pytest.mark.parametrize("addr_param", [{"in": "192.168.0.5", "out": False}, 267 {"in": "2607:f2b1:f081:9:1c8c:f1c7:47e:f121", "out": True}]) 268 def test_validate_ip_v6_address(self, addr_param): 269 ret_val = self.module.validate_ip_v6_address(addr_param["in"]) 270 assert ret_val == addr_param["out"] 271 272 src_dict1 = {"Enable": False, "EnableDHCP": True, "UseDHCPForDNSServerNames": False, 273 "StaticGateway": "192.168.11.2", 274 "StaticIPAddress": "192.168.11.20", "StaticSubnetMask": "255.255.255.0", 275 "StaticPreferredDNSServer": "192.168.11.3", "EnableAutoConfiguration": True} 276 new_dict1 = {"Enable": True, "EnableDHCP": False, "StaticGateway": "192.168.11.1", 277 "UseDHCPForDNSServerNames": True, "StaticPreferredDNSServer": "192.168.11.2", 278 "StaticAlternateDNSServer": "192.168.11.3"} 279 src_dict2 = {"StaticIPAddress": "192.168.11.20", "StaticSubnetMask": "255.255.255.0", 280 "EnableAutoConfiguration": False} 281 new_dict2 = {"StaticIPAddress": "192.168.11.20", "StaticSubnetMask": "255.255.255.0"} 282 283 @pytest.mark.parametrize("addr_param", [{"src_dict": src_dict1, "new_dict": new_dict1, 'diff': 4}, 284 {"src_dict": src_dict2, "new_dict": new_dict2, 'diff': False}, 285 {"src_dict": src_dict2, "new_dict": {}, 'diff': 0}, 286 {"src_dict": src_dict2, "new_dict": {"EnableDHCP": None}, 'diff': 0} 287 ]) 288 def test_update_ipv4_payload(self, addr_param): 289 ret_val = self.module.update_ipv4_payload(addr_param["src_dict"], addr_param["new_dict"]) 290 assert ret_val == addr_param['diff'] 291 292 v6src_dict1 = {"Enable": False, "UseDHCPForDNSServerNames": False, 293 "StaticGateway": "192.168.11.2", 294 "StaticIPAddress": "192.168.11.20", "StaticSubnetMask": "255.255.255.0", 295 "StaticPreferredDNSServer": "192.168.11.3", "EnableAutoConfiguration": False} 296 v6new_dict1 = {"Enable": True, "EnableAutoConfiguration": True, "StaticGateway": "192.168.11.1", 297 "UseDHCPForDNSServerNames": True, "StaticPreferredDNSServer": "2607:f2b1:f081:9:1c8c:f1c7:47e:f122", 298 "StaticAlternateDNSServer": "2607:f2b1:f081:9:1c8c:f1c7:47e:f121"} 299 300 @pytest.mark.parametrize("addr_param", [{"src_dict": v6src_dict1, "new_dict": v6new_dict1, 'diff': 3}, 301 {"src_dict": v6src_dict1, "new_dict": {}, 'diff': 0}]) 302 def test_update_ipv6_payload(self, addr_param): 303 ret_val = self.module.update_ipv6_payload(addr_param["src_dict"], addr_param["new_dict"]) 304 assert ret_val == addr_param['diff'] 305 306 dns_src = {"RegisterWithDNS": False, "DnsName": "openmanage-enterprise", 307 "UseDHCPForDNSDomainName": False, "DnsDomainName": "localdomain"} 308 dns_new = {"RegisterWithDNS": True, "DnsName": "openmanage-enterprise1", 309 "UseDHCPForDNSDomainName": True, "DnsDomainName": "localdomain1"} 310 311 @pytest.mark.parametrize("addr_param", [{"src_dict": dns_src, "new_dict": dns_new, 'diff': 3}, 312 {"src_dict": dns_src, "new_dict": {}, 'diff': 0}, 313 {"src_dict": dns_src, "new_dict": {"RegisterWithDNS": None, 314 "UseDHCPForDNSDomainName": None}, 315 'diff': 0}]) 316 def test_update_dns_payload(self, addr_param): 317 ret_val = self.module.update_dns_payload(addr_param["src_dict"], addr_param["new_dict"]) 318 assert ret_val == addr_param['diff'] 319 320 vlan_src = {"EnableVLAN": False, "Id": 0} 321 vlan_new = {"EnableVLAN": True, "Id": 1} 322 323 @pytest.mark.parametrize("addr_param", [{"src_dict": vlan_src, "new_dict": vlan_new, 'diff': 2}, 324 {"src_dict": vlan_src, "new_dict": {}, 'diff': 0}, 325 {"src_dict": vlan_src, "new_dict": {"EnableVLAN": None}, 'diff': 0}]) 326 def test_update_vlan_payload(self, addr_param): 327 ret_val = self.module.update_vlan_payload(addr_param["src_dict"], addr_param["new_dict"]) 328 assert ret_val == addr_param['diff'] 329 330 @pytest.mark.parametrize("exc_type", 331 [IOError, ValueError, SSLError, TypeError, ConnectionError, HTTPError, URLError]) 332 def test_ome_application_network_address_main_success_failure_case1(self, exc_type, mocker, ome_default_args, 333 ome_connection_mock_for_application_network_address, 334 ome_response_mock): 335 ome_default_args.update({"dns_configuration": {"dns_domain_name": "localdomain"}, 336 "ipv4_configuration": {"enable": True, "enable_dhcp": True}, 337 "ipv6_configuration": {"enable": False, "enable_auto_configuration": True}}) 338 json_str = to_text(json.dumps({"info": "error_details"})) 339 if exc_type == URLError: 340 mocker.patch(MODULE_PATH + 'ome_application_network_address.validate_input', 341 side_effect=exc_type("url open error")) 342 ome_default_args.update({"dns_configuration": {"dns_domain_name": "localdomain"}, 343 "ipv4_configuration": {"enable": True, "enable_dhcp": True}, 344 "ipv6_configuration": {"enable": False, "enable_auto_configuration": True}}) 345 result = self._run_module(ome_default_args) 346 assert result["unreachable"] is True 347 elif exc_type not in [HTTPError, SSLValidationError]: 348 mocker.patch(MODULE_PATH + 'ome_application_network_address.validate_input', 349 side_effect=exc_type("exception message")) 350 result = self._run_module_with_fail_json(ome_default_args) 351 assert result['failed'] is True 352 else: 353 mocker.patch(MODULE_PATH + 'ome_application_network_address.validate_input', 354 side_effect=exc_type('http://testhost.com', 400, 355 'http error message', 356 {"accept-type": "application/json"}, 357 StringIO(json_str))) 358 result = self._run_module_with_fail_json(ome_default_args) 359 assert result['failed'] is True 360 assert 'network_configuration' not in result 361 assert 'msg' in result 362 363 def test_get_network_config_data_case_01(self, ome_connection_mock_for_application_network_address, 364 ome_response_mock): 365 param = {} 366 ome_response_mock.json_data = {"value": [{"PrimaryInterface": "val1"}]} 367 f_module = self.get_module_mock(params=param) 368 nt_adp, method, POST_IP_CONFIG = self.module.get_network_config_data( 369 ome_connection_mock_for_application_network_address, f_module) 370 assert nt_adp == {'PrimaryInterface': 'val1'} 371 assert method == "POST" 372 assert POST_IP_CONFIG == "ApplicationService/Actions/Network.ConfigureNetworkAdapter" 373 374 def test_get_network_config_data_case_02(self, ome_connection_mock_for_application_network_address, 375 ome_response_mock): 376 param = {"interface_name": "val1"} 377 ome_response_mock.json_data = {"value": [{"InterfaceName": "val1"}]} 378 f_module = self.get_module_mock(params=param) 379 nt_adp, method, POST_IP_CONFIG = self.module.get_network_config_data( 380 ome_connection_mock_for_application_network_address, f_module) 381 assert nt_adp == {'InterfaceName': 'val1'} 382 assert method == "POST" 383 assert POST_IP_CONFIG == "ApplicationService/Actions/Network.ConfigureNetworkAdapter" 384 385 def test_get_network_config_data_case_03(self, ome_connection_mock_for_application_network_address, 386 ome_response_mock): 387 388 param = {"interface_name": "interface_name"} 389 ome_response_mock.json_data = {"value": [{"InterfaceName": "val2", "PrimaryInterface": "val3"}]} 390 f_module = self.get_module_mock(params=param) 391 nt_adp, method, POST_IP_CONFIG = self.module.get_network_config_data( 392 ome_connection_mock_for_application_network_address, f_module) 393 assert nt_adp == "val3" 394 assert method == "POST" 395 assert POST_IP_CONFIG == "ApplicationService/Actions/Network.ConfigureNetworkAdapter" 396 397 def test_get_network_config_data_case_03(self, ome_connection_mock_for_application_network_address, 398 ome_response_mock): 399 param = {} 400 ome_response_mock.json_data = {"value": []} 401 f_module = self.get_module_mock(params=param) 402 nt_adp, method, POST_IP_CONFIG = self.module.get_network_config_data( 403 ome_connection_mock_for_application_network_address, f_module) 404 assert nt_adp is None 405 assert method == "POST" 406 assert POST_IP_CONFIG == "ApplicationService/Actions/Network.ConfigureNetworkAdapter" 407 408 def test_get_network_config_data_exception_case_01(self, ome_connection_mock_for_application_network_address, 409 ome_response_mock): 410 param = {"interface_name": "interface_name_val"} 411 ome_response_mock.json_data = {"value": []} 412 f_module = self.get_module_mock(params=param) 413 msg = "The 'interface_name' value provided interface_name_val is invalid" 414 with pytest.raises(Exception) as exc: 415 self.module.get_network_config_data(ome_connection_mock_for_application_network_address, f_module) 416 assert exc.value.args[0] == msg 417 418 def test_get_network_config_data_exception_case_02(self, ome_connection_mock_for_application_network_address): 419 param = {} 420 msg = "exception message" 421 ome_connection_mock_for_application_network_address.invoke_request.side_effect = Exception("exception message") 422 f_module = self.get_module_mock(params=param) 423 with pytest.raises(Exception, match=msg): 424 self.module.get_network_config_data( 425 ome_connection_mock_for_application_network_address, f_module) 426