def test_should_get_a_logical_interconnect_by_name_with_ethernet_settings(
            self):
        ethernet_settings = {
            "id":
            "235d50d7-cf4a-4362-aec3-c4914c6ebab4",
            "igmpIdleTimeoutInterval":
            260,
            "interconnectType":
            "Ethernet",
            "macRefreshInterval":
            5,
            "modified":
            "2016-12-20T16:48:08.626Z",
            "name":
            "ES634039453",
            "uri":
            "/rest/logical-interconnects/d1c7b09a-6c7b-4ae0-b68e-ed208ccde1b0/ethernetSettings"
        }
        self.logical_interconnects.get_by_name.return_value = LOGICAL_INTERCONNECT
        self.logical_interconnects.get_ethernet_settings.return_value = ethernet_settings
        self.mock_ansible_module.params = create_params(['ethernet_settings'])

        LogicalInterconnectFactsModule().run()

        self.logical_interconnects.get_ethernet_settings.assert_called_once_with(
            id_or_uri=LOGICAL_INTERCONNECT_URI)

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=LOGICAL_INTERCONNECT,
                               ethernet_settings=ethernet_settings))
    def test_should_get_all_logical_interconnects(self):
        self.logical_interconnects.get_all.return_value = ALL_INTERCONNECTS

        self.mock_ansible_module.params = PARAMS_GET_ALL

        LogicalInterconnectFactsModule().run()

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=ALL_INTERCONNECTS))
    def test_should_fail_when_logical_interconnect_not_exist(self):
        params = create_params(['unassigned_uplink_ports'])

        self.logical_interconnects.get_by_name.return_value = None

        self.mock_ansible_module.params = params

        LogicalInterconnectFactsModule().run()

        self.mock_ansible_module.fail_json.assert_called_once_with(
            msg=LOGICAL_INTERCONNECT_NOT_FOUND)
    def test_should_load_config_from_file(self, mock_ansible_module,
                                          mock_ov_client_from_env_vars,
                                          mock_ov_client_from_json_file):
        mock_ov_instance = mock.Mock()
        mock_ov_client_from_json_file.return_value = mock_ov_instance
        mock_ansible_instance = create_ansible_mock({'config': 'config.json'})
        mock_ansible_module.return_value = mock_ansible_instance

        LogicalInterconnectFactsModule()

        mock_ov_client_from_json_file.assert_called_once_with('config.json')
        mock_ov_client_from_env_vars.not_been_called()
    def test_should_fail_when_get_all_raises_an_exception(
            self, mock_ansible_module, mock_ov_from_file):
        mock_ov_instance = mock.Mock()
        mock_ov_instance.logical_interconnects.get_all.side_effect = Exception(
            ERROR_MSG)
        mock_ov_from_file.return_value = mock_ov_instance

        mock_ansible_instance = create_ansible_mock(PARAMS_GET_ALL)
        mock_ansible_module.return_value = mock_ansible_instance

        LogicalInterconnectFactsModule().run()
        mock_ansible_instance.fail_json.assert_called_once_with(msg=ERROR_MSG)
    def test_should_get_a_logical_interconnects_by_name(self):
        self.logical_interconnects.get_by_name.return_value = LOGICAL_INTERCONNECT
        self.mock_ansible_module.params = create_params()

        LogicalInterconnectFactsModule().run()

        self.logical_interconnects.get_by_name.assert_called_once_with(
            name=LOGICAL_INTERCONNECT_NAME)

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=LOGICAL_INTERCONNECT))
    def test_should_get_a_logical_interconnects_by_name(
            self, mock_ansible_module, mock_ov_from_file):
        mock_ov_instance, mock_ansible_instance = define_mocks_for_get_by_name(
            mock_ov_from_file, mock_ansible_module, create_params())

        LogicalInterconnectFactsModule().run()

        mock_ov_instance.logical_interconnects.get_by_name.assert_called_once_with(
            name=LOGICAL_INTERCONNECT_NAME)

        mock_ansible_instance.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=LOGICAL_INTERCONNECT))
    def test_should_get_a_logical_interconnects_by_name_with_firmware(self):
        self.logical_interconnects.get_by_name.return_value = LOGICAL_INTERCONNECT
        self.logical_interconnects.get_firmware.return_value = FIRMWARE
        self.mock_ansible_module.params = create_params(['firmware'])

        LogicalInterconnectFactsModule().run()

        self.logical_interconnects.get_firmware.assert_called_once_with(
            id_or_uri=LOGICAL_INTERCONNECT_URI)

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=LOGICAL_INTERCONNECT,
                               firmware=FIRMWARE))
    def test_should_get_all_logical_interconnects(self, mock_ansible_module,
                                                  mock_ov_from_file):
        mock_ov_instance = mock.Mock()
        mock_ov_instance.logical_interconnects.get_all.return_value = ALL_INTERCONNECTS
        mock_ov_from_file.return_value = mock_ov_instance

        mock_ansible_instance = create_ansible_mock(PARAMS_GET_ALL)
        mock_ansible_module.return_value = mock_ansible_instance

        LogicalInterconnectFactsModule().run()

        mock_ansible_instance.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=ALL_INTERCONNECTS))
    def test_should_fail_when_logical_interconnect_not_exist(
            self, mock_ansible_module, mock_ov_from_file):
        params = create_params(['unassigned_uplink_ports'])

        mock_ov_instance = mock.Mock()
        mock_ov_instance.logical_interconnects.get_by_name.return_value = None
        mock_ov_from_file.return_value = mock_ov_instance

        mock_ansible_instance = create_ansible_mock(params)
        mock_ansible_module.return_value = mock_ansible_instance

        LogicalInterconnectFactsModule().run()

        mock_ansible_instance.fail_json.assert_called_once_with(
            msg=LOGICAL_INTERCONNECT_NOT_FOUND)
    def test_should_get_a_logical_interconnects_by_name_with_forwarding_information_base(
            self):
        self.logical_interconnects.get_by_name.return_value = LOGICAL_INTERCONNECT
        self.logical_interconnects.get_internal_vlans.return_value = INTERNAL_VLANS
        self.mock_ansible_module.params = create_params(['internal_vlans'])

        LogicalInterconnectFactsModule().run()

        self.logical_interconnects.get_internal_vlans.assert_called_once_with(
            id_or_uri=LOGICAL_INTERCONNECT_URI)

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=LOGICAL_INTERCONNECT,
                               internal_vlans=INTERNAL_VLANS))
    def test_should_get_a_logical_interconnects_by_name_with_port_monitor(
            self):
        self.logical_interconnects.get_by_name.return_value = LOGICAL_INTERCONNECT
        self.logical_interconnects.get_port_monitor.return_value = PORT_MONITOR
        self.mock_ansible_module.params = create_params(['port_monitor'])

        LogicalInterconnectFactsModule().run()

        self.logical_interconnects.get_port_monitor.assert_called_once_with(
            id_or_uri=LOGICAL_INTERCONNECT_URI)

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=LOGICAL_INTERCONNECT,
                               port_monitor=PORT_MONITOR))
    def test_should_get_a_logical_interconnects_by_name_with_snmp_configuration(
            self):
        self.logical_interconnects.get_by_name.return_value = LOGICAL_INTERCONNECT
        self.logical_interconnects.get_snmp_configuration.return_value = SNMP_CONFIGURATION
        self.mock_ansible_module.params = create_params(['snmp_configuration'])

        LogicalInterconnectFactsModule().run()

        self.logical_interconnects.get_snmp_configuration.assert_called_once_with(
            id_or_uri=LOGICAL_INTERCONNECT_URI)

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=LOGICAL_INTERCONNECT,
                               snmp_configuration=SNMP_CONFIGURATION))
    def test_should_get_a_logical_interconnects_by_name_with_unassigned_uplink_ports(
            self):
        self.logical_interconnects.get_by_name.return_value = LOGICAL_INTERCONNECT
        self.logical_interconnects.get_unassigned_uplink_ports.return_value = UNASSIGNED_UPLINK_PORTS
        self.mock_ansible_module.params = create_params(
            ['unassigned_uplink_ports'])

        LogicalInterconnectFactsModule().run()

        self.logical_interconnects.get_unassigned_uplink_ports.assert_called_once_with(
            id_or_uri=LOGICAL_INTERCONNECT_URI)

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(
                logical_interconnects=LOGICAL_INTERCONNECT,
                unassigned_uplink_ports=UNASSIGNED_UPLINK_PORTS))
    def test_should_get_a_logical_interconnects_by_name_with_multiple_options(
            self, mock_ansible_module, mock_ov_from_file):
        params = create_params([
            'qos_aggregated_configuration', 'snmp_configuration',
            'port_monitor', 'unassigned_uplink_ports',
            'telemetry_configuration'
        ])

        mock_ov_instance, mock_ansible_instance = define_mocks_for_get_by_name(
            mock_ov_from_file, mock_ansible_module, params)

        mock_ov_instance.logical_interconnects.get_qos_aggregated_configuration.return_value = QOS_CONFIGURATION
        mock_ov_instance.logical_interconnects.get_snmp_configuration.return_value = SNMP_CONFIGURATION
        mock_ov_instance.logical_interconnects.get_port_monitor.return_value = PORT_MONITOR
        mock_ov_instance.logical_interconnects.get_unassigned_uplink_ports.return_value = UNASSIGNED_UPLINK_PORTS
        mock_ov_instance.logical_interconnects.get_telemetry_configuration.return_value = TELEMETRY_CONFIGURATION

        LogicalInterconnectFactsModule().run()

        expected_uri = dict(id_or_uri=LOGICAL_INTERCONNECT_URI)
        telemetry_uri = dict(telemetry_configuration_uri=TELEMETRY_CONF_URI)

        # validate the calls to the OneView SDK
        mock_ov_instance.logical_interconnects.get_by_name.assert_called_once_with(
            name=LOGICAL_INTERCONNECT_NAME)
        mock_ov_instance.logical_interconnects.get_qos_aggregated_configuration.assert_called_once_with(
            **expected_uri)
        mock_ov_instance.logical_interconnects.get_snmp_configuration.assert_called_once_with(
            **expected_uri)
        mock_ov_instance.logical_interconnects.get_port_monitor.assert_called_once_with(
            **expected_uri)
        mock_ov_instance.logical_interconnects.get_unassigned_uplink_ports.assert_called_once_with(
            **expected_uri)
        mock_ov_instance.logical_interconnects.get_telemetry_configuration.assert_called_once_with(
            **telemetry_uri)

        # Validate the result data
        mock_ansible_instance.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(
                logical_interconnects=LOGICAL_INTERCONNECT,
                qos_aggregated_configuration=QOS_CONFIGURATION,
                snmp_configuration=SNMP_CONFIGURATION,
                port_monitor=PORT_MONITOR,
                unassigned_uplink_ports=UNASSIGNED_UPLINK_PORTS,
                telemetry_configuration=TELEMETRY_CONFIGURATION))
    def test_should_get_a_logical_interconnects_by_name_with_snmp_configuration(
            self, mock_ansible_module, mock_ov_from_file):
        params = create_params(['snmp_configuration'])

        mock_ov_instance, mock_ansible_instance = define_mocks_for_get_by_name(
            mock_ov_from_file, mock_ansible_module, params)

        mock_ov_instance.logical_interconnects.get_snmp_configuration.return_value = SNMP_CONFIGURATION

        LogicalInterconnectFactsModule().run()

        mock_ov_instance.logical_interconnects.get_snmp_configuration.assert_called_once_with(
            id_or_uri=LOGICAL_INTERCONNECT_URI)

        mock_ansible_instance.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=LOGICAL_INTERCONNECT,
                               snmp_configuration=SNMP_CONFIGURATION))
    def test_should_get_a_logical_interconnects_by_name_with_firmware(
            self, mock_ansible_module, mock_ov_from_file):
        params = create_params(['firmware'])

        mock_ov_instance, mock_ansible_instance = define_mocks_for_get_by_name(
            mock_ov_from_file, mock_ansible_module, params)

        mock_ov_instance.logical_interconnects.get_firmware.return_value = FIRMWARE

        LogicalInterconnectFactsModule().run()

        mock_ov_instance.logical_interconnects.get_firmware.assert_called_once_with(
            id_or_uri=LOGICAL_INTERCONNECT_URI)

        mock_ansible_instance.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=LOGICAL_INTERCONNECT,
                               firmware=FIRMWARE))
    def test_should_get_a_logical_interconnects_by_name_with_forwarding_information_base(
            self, mock_ansible_module, mock_ov_from_file):
        params = create_params(['internal_vlans'])

        mock_ov_instance, mock_ansible_instance = define_mocks_for_get_by_name(
            mock_ov_from_file, mock_ansible_module, params)

        mock_ov_instance.logical_interconnects.get_internal_vlans.return_value = INTERNAL_VLANS

        LogicalInterconnectFactsModule().run()

        mock_ov_instance.logical_interconnects.get_internal_vlans.assert_called_once_with(
            id_or_uri=LOGICAL_INTERCONNECT_URI)

        mock_ansible_instance.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=LOGICAL_INTERCONNECT,
                               internal_vlans=INTERNAL_VLANS))
    def test_should_get_a_logical_interconnects_by_name_with_port_monitor(
            self, mock_ansible_module, mock_ov_from_file):
        params = create_params(['port_monitor'])

        mock_ov_instance, mock_ansible_instance = define_mocks_for_get_by_name(
            mock_ov_from_file, mock_ansible_module, params)

        mock_ov_instance.logical_interconnects.get_port_monitor.return_value = PORT_MONITOR

        LogicalInterconnectFactsModule().run()

        mock_ov_instance.logical_interconnects.get_port_monitor.assert_called_once_with(
            id_or_uri=LOGICAL_INTERCONNECT_URI)

        mock_ansible_instance.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(logical_interconnects=LOGICAL_INTERCONNECT,
                               port_monitor=PORT_MONITOR))
    def test_should_get_a_logical_interconnects_by_name_with_unassigned_uplink_ports(
            self, mock_ansible_module, mock_ov_from_file):
        params = create_params(['unassigned_uplink_ports'])

        mock_ov_instance, mock_ansible_instance = define_mocks_for_get_by_name(
            mock_ov_from_file, mock_ansible_module, params)

        mock_ov_instance.logical_interconnects.get_unassigned_uplink_ports.return_value = UNASSIGNED_UPLINK_PORTS

        LogicalInterconnectFactsModule().run()

        mock_ov_instance.logical_interconnects.get_unassigned_uplink_ports.assert_called_once_with(
            id_or_uri=LOGICAL_INTERCONNECT_URI)

        mock_ansible_instance.exit_json.assert_called_once_with(
            changed=False,
            ansible_facts=dict(
                logical_interconnects=LOGICAL_INTERCONNECT,
                unassigned_uplink_ports=UNASSIGNED_UPLINK_PORTS))