# Copyright 2013 Cloudbase Solutions SRL
# All Rights Reserved.
#
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.

"""
Unit tests for the Hyper-V utils V2.
"""

import mock

from neutron.plugins.hyperv.agent import utils
from neutron.plugins.hyperv.agent import utilsv2
from neutron.tests import base


class TestHyperVUtilsV2(base.BaseTestCase):

    _FAKE_VSWITCH_NAME = "fake_vswitch_name"
    _FAKE_PORT_NAME = "fake_port_name"
    _FAKE_JOB_PATH = 'fake_job_path'
    _FAKE_RET_VAL = 0
    _FAKE_VM_PATH = "fake_vm_path"
    _FAKE_RES_DATA = "fake_res_data"
    _FAKE_RES_PATH = "fake_res_path"
    _FAKE_VSWITCH = "fake_vswitch"
    _FAKE_VLAN_ID = "fake_vlan_id"
    _FAKE_CLASS_NAME = "fake_class_name"
    _FAKE_ELEMENT_NAME = "fake_element_name"
    _FAKE_HYPERV_VM_STATE = 'fake_hyperv_state'

    _FAKE_ACL_ACT = 'fake_acl_action'
    _FAKE_ACL_DIR = 'fake_acl_dir'
    _FAKE_ACL_TYPE = 'fake_acl_type'
    _FAKE_LOCAL_PORT = 'fake_local_port'
    _FAKE_PROTOCOL = 'fake_port_protocol'
    _FAKE_REMOTE_ADDR = '0.0.0.0/0'
    _FAKE_WEIGHT = 'fake_weight'

    def setUp(self):
        super(TestHyperVUtilsV2, self).setUp()
        self._utils = utilsv2.HyperVUtilsV2()
        self._utils._wmi_conn = mock.MagicMock()

    def test_connect_vnic_to_vswitch_found(self):
        self._test_connect_vnic_to_vswitch(True)

    def test_connect_vnic_to_vswitch_not_found(self):
        self._test_connect_vnic_to_vswitch(False)

    def _test_connect_vnic_to_vswitch(self, found):
        self._utils._get_vnic_settings = mock.MagicMock()

        if not found:
            mock_vm = mock.MagicMock()
            self._utils._get_vm_from_res_setting_data = mock.MagicMock(
                return_value=mock_vm)
            self._utils._add_virt_resource = mock.MagicMock()
        else:
            self._utils._modify_virt_resource = mock.MagicMock()

        self._utils._get_vswitch = mock.MagicMock()
        self._utils._get_switch_port_allocation = mock.MagicMock()

        mock_port = mock.MagicMock()
        self._utils._get_switch_port_allocation.return_value = (mock_port,
                                                                found)

        self._utils.connect_vnic_to_vswitch(self._FAKE_VSWITCH_NAME,
                                            self._FAKE_PORT_NAME)

        if not found:
            self._utils._add_virt_resource.assert_called_with(mock_vm,
                                                              mock_port)
        else:
            self._utils._modify_virt_resource.assert_called_with(mock_port)

    def test_add_virt_resource(self):
        self._test_virt_method('AddResourceSettings', 3, '_add_virt_resource',
                               True, self._FAKE_VM_PATH, [self._FAKE_RES_DATA])

    def test_add_virt_feature(self):
        self._test_virt_method('AddFeatureSettings', 3, '_add_virt_feature',
                               True, self._FAKE_VM_PATH, [self._FAKE_RES_DATA])

    def test_modify_virt_resource(self):
        self._test_virt_method('ModifyResourceSettings', 3,
                               '_modify_virt_resource', False,
                               ResourceSettings=[self._FAKE_RES_DATA])

    def test_remove_virt_resource(self):
        self._test_virt_method('RemoveResourceSettings', 2,
                               '_remove_virt_resource', False,
                               ResourceSettings=[self._FAKE_RES_PATH])

    def test_remove_virt_feature(self):
        self._test_virt_method('RemoveFeatureSettings', 2,
                               '_remove_virt_feature', False,
                               FeatureSettings=[self._FAKE_RES_PATH])

    def _test_virt_method(self, vsms_method_name, return_count,
                          utils_method_name, with_mock_vm, *args, **kwargs):
        mock_svc = self._utils._conn.Msvm_VirtualSystemManagementService()[0]
        vsms_method = getattr(mock_svc, vsms_method_name)
        mock_rsd = self._mock_vsms_method(vsms_method, return_count)
        if with_mock_vm:
            mock_vm = mock.MagicMock()
            mock_vm.path_.return_value = self._FAKE_VM_PATH
            getattr(self._utils, utils_method_name)(mock_vm, mock_rsd)
        else:
            getattr(self._utils, utils_method_name)(mock_rsd)

        if args:
            vsms_method.assert_called_once_with(*args)
        else:
            vsms_method.assert_called_once_with(**kwargs)

    def _mock_vsms_method(self, vsms_method, return_count):
        args = None
        if return_count == 3:
            args = (self._FAKE_JOB_PATH, mock.MagicMock(), self._FAKE_RET_VAL)
        else:
            args = (self._FAKE_JOB_PATH, self._FAKE_RET_VAL)

        vsms_method.return_value = args
        mock_res_setting_data = mock.MagicMock()
        mock_res_setting_data.GetText_.return_value = self._FAKE_RES_DATA
        mock_res_setting_data.path_.return_value = self._FAKE_RES_PATH

        self._utils._check_job_status = mock.MagicMock()

        return mock_res_setting_data

    def test_disconnect_switch_port_delete_port(self):
        self._test_disconnect_switch_port(True)

    def test_disconnect_switch_port_modify_port(self):
        self._test_disconnect_switch_port(False)

    def _test_disconnect_switch_port(self, delete_port):
        self._utils._get_switch_port_allocation = mock.MagicMock()

        mock_sw_port = mock.MagicMock()
        self._utils._get_switch_port_allocation.return_value = (mock_sw_port,
                                                                True)

        if delete_port:
            self._utils._remove_virt_resource = mock.MagicMock()
        else:
            self._utils._modify_virt_resource = mock.MagicMock()

        self._utils.disconnect_switch_port(self._FAKE_VSWITCH_NAME,
                                           self._FAKE_PORT_NAME,
                                           delete_port)

        if delete_port:
            self._utils._remove_virt_resource.assert_called_with(mock_sw_port)
        else:
            self._utils._modify_virt_resource.assert_called_with(mock_sw_port)

    def test_get_vswitch(self):
        self._utils._conn.Msvm_VirtualEthernetSwitch.return_value = [
            self._FAKE_VSWITCH]
        vswitch = self._utils._get_vswitch(self._FAKE_VSWITCH_NAME)

        self.assertEqual(self._FAKE_VSWITCH, vswitch)

    def test_get_vswitch_not_found(self):
        self._utils._conn.Msvm_VirtualEthernetSwitch.return_value = []
        self.assertRaises(utils.HyperVException, self._utils._get_vswitch,
                          self._FAKE_VSWITCH_NAME)

    def test_get_vswitch_external_port(self):
        mock_vswitch = mock.MagicMock()
        mock_sw_port = mock.MagicMock()
        mock_vswitch.associators.return_value = [mock_sw_port]
        mock_le = mock_sw_port.associators.return_value
        mock_le.__len__.return_value = 1
        mock_le1 = mock_le[0].associators.return_value
        mock_le1.__len__.return_value = 1

        vswitch_port = self._utils._get_vswitch_external_port(mock_vswitch)

        self.assertEqual(mock_sw_port, vswitch_port)

    def test_set_vswitch_port_vlan_id(self):
        mock_port_alloc = mock.MagicMock()
        self._utils._get_switch_port_allocation = mock.MagicMock(return_value=(
            mock_port_alloc, True))
        self._utils._get_vlan_setting_data_from_port_alloc = mock.MagicMock()

        mock_svc = self._utils._conn.Msvm_VirtualSystemManagementService()[0]
        mock_svc.RemoveFeatureSettings.return_value = (self._FAKE_JOB_PATH,
                                                       self._FAKE_RET_VAL)
        mock_vlan_settings = mock.MagicMock()
        self._utils._get_vlan_setting_data = mock.MagicMock(return_value=(
            mock_vlan_settings, True))

        mock_svc.AddFeatureSettings.return_value = (self._FAKE_JOB_PATH,
                                                    None,
                                                    self._FAKE_RET_VAL)

        self._utils.set_vswitch_port_vlan_id(self._FAKE_VLAN_ID,
                                             self._FAKE_PORT_NAME)

        self.assertTrue(mock_svc.RemoveFeatureSettings.called)
        self.assertTrue(mock_svc.AddFeatureSettings.called)

    def test_get_setting_data(self):
        self._utils._get_first_item = mock.MagicMock(return_value=None)

        mock_data = mock.MagicMock()
        self._utils._get_default_setting_data = mock.MagicMock(
            return_value=mock_data)

        ret_val = self._utils._get_setting_data(self._FAKE_CLASS_NAME,
                                                self._FAKE_ELEMENT_NAME,
                                                True)

        self.assertEqual(ret_val, (mock_data, False))

    def test_enable_port_metrics_collection(self):
        mock_port = mock.MagicMock()
        self._utils._get_switch_port_allocation = mock.MagicMock(return_value=(
            mock_port, True))

        mock_acl = mock.MagicMock()

        with mock.patch.multiple(
            self._utils,
            _get_default_setting_data=mock.MagicMock(return_value=mock_acl),
            _add_virt_feature=mock.MagicMock()):

            self._utils.enable_port_metrics_collection(self._FAKE_PORT_NAME)

            self.assertEqual(4, len(self._utils._add_virt_feature.mock_calls))
            self._utils._add_virt_feature.assert_called_with(
                mock_port, mock_acl)

    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._get_switch_port_allocation')
    def test_enable_control_metrics_ok(self, mock_get_port_allocation):
        mock_metrics_svc = self._utils._conn.Msvm_MetricService()[0]
        mock_metrics_def_source = self._utils._conn.CIM_BaseMetricDefinition
        mock_metric_def = mock.MagicMock()
        mock_port = mock.MagicMock()
        mock_get_port_allocation.return_value = (mock_port, True)

        mock_metrics_def_source.return_value = [mock_metric_def]
        m_call = mock.call(Subject=mock_port.path_.return_value,
                           Definition=mock_metric_def.path_.return_value,
                           MetricCollectionEnabled=self._utils._METRIC_ENABLED)

        self._utils.enable_control_metrics(self._FAKE_PORT_NAME)

        mock_metrics_svc.ControlMetrics.assert_has_calls([m_call, m_call])

    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._get_switch_port_allocation')
    def test_enable_control_metrics_no_port(self, mock_get_port_allocation):
        mock_metrics_svc = self._utils._conn.Msvm_MetricService()[0]
        mock_get_port_allocation.return_value = (None, False)

        self._utils.enable_control_metrics(self._FAKE_PORT_NAME)
        self.assertEqual(0, mock_metrics_svc.ControlMetrics.call_count)

    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._get_switch_port_allocation')
    def test_enable_control_metrics_no_def(self, mock_get_port_allocation):
        mock_metrics_svc = self._utils._conn.Msvm_MetricService()[0]
        mock_metrics_def_source = self._utils._conn.CIM_BaseMetricDefinition
        mock_port = mock.MagicMock()

        mock_get_port_allocation.return_value = (mock_port, True)
        mock_metrics_def_source.return_value = None

        self._utils.enable_control_metrics(self._FAKE_PORT_NAME)
        self.assertEqual(0, mock_metrics_svc.ControlMetrics.call_count)

    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._is_port_vm_started')
    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._get_switch_port_allocation')
    def test_can_enable_control_metrics_true(self, mock_get, mock_is_started):
        mock_acl = mock.MagicMock()
        mock_acl.Action = self._utils._ACL_ACTION_METER
        self._test_can_enable_control_metrics(mock_get, mock_is_started,
                                              [mock_acl, mock_acl], True)

    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._is_port_vm_started')
    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._get_switch_port_allocation')
    def test_can_enable_control_metrics_false(self, mock_get, mock_is_started):
        self._test_can_enable_control_metrics(mock_get, mock_is_started, [],
                                              False)

    def _test_can_enable_control_metrics(self, mock_get_port, mock_vm_started,
                                         acls, expected_result):
        mock_port = mock.MagicMock()
        mock_acl = mock.MagicMock()
        mock_acl.Action = self._utils._ACL_ACTION_METER

        mock_port.associators.return_value = acls
        mock_get_port.return_value = (mock_port, True)
        mock_vm_started.return_value = True

        result = self._utils.can_enable_control_metrics(self._FAKE_PORT_NAME)
        self.assertEqual(expected_result, result)

    def test_is_port_vm_started_true(self):
        self._test_is_port_vm_started(self._utils._HYPERV_VM_STATE_ENABLED,
                                      True)

    def test_is_port_vm_started_false(self):
        self._test_is_port_vm_started(self._FAKE_HYPERV_VM_STATE, False)

    def _test_is_port_vm_started(self, vm_state, expected_result):
        mock_svc = self._utils._conn.Msvm_VirtualSystemManagementService()[0]
        mock_port = mock.MagicMock()
        mock_vmsettings = mock.MagicMock()
        mock_summary = mock.MagicMock()
        mock_summary.EnabledState = vm_state
        mock_vmsettings.path_.return_value = self._FAKE_RES_PATH

        mock_port.associators.return_value = [mock_vmsettings]
        mock_svc.GetSummaryInformation.return_value = (self._FAKE_RET_VAL,
                                                       [mock_summary])

        result = self._utils._is_port_vm_started(mock_port)
        self.assertEqual(expected_result, result)
        mock_svc.GetSummaryInformation.assert_called_once_with(
            [self._utils._VM_SUMMARY_ENABLED_STATE],
            [self._FAKE_RES_PATH])

    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._remove_virt_feature')
    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._bind_security_rule')
    def test_create_default_reject_all_rules(self, mock_bind, mock_remove):
        (m_port, m_acl) = self._setup_security_rule_test()
        m_acl.Action = self._utils._ACL_ACTION_DENY
        self._utils.create_default_reject_all_rules(self._FAKE_PORT_NAME)

        calls = []
        ipv4_pair = (self._utils._ACL_TYPE_IPV4, self._utils._IPV4_ANY)
        ipv6_pair = (self._utils._ACL_TYPE_IPV6, self._utils._IPV6_ANY)
        for direction in [self._utils._ACL_DIR_IN, self._utils._ACL_DIR_OUT]:
            for acl_type, address in [ipv4_pair, ipv6_pair]:
                for protocol in [self._utils._TCP_PROTOCOL,
                                 self._utils._UDP_PROTOCOL,
                                 self._utils._ICMP_PROTOCOL]:
                    calls.append(mock.call(m_port, direction, acl_type,
                                           self._utils._ACL_ACTION_DENY,
                                           self._utils._ACL_DEFAULT,
                                           protocol, address, mock.ANY))

        self._utils._remove_virt_feature.assert_called_once_with(m_acl)
        self._utils._bind_security_rule.assert_has_calls(calls)

    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._remove_virt_feature')
    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._bind_security_rule')
    def test_create_default_reject_all_rules_already_added(self, mock_bind,
                                                           mock_remove):
        (m_port, m_acl) = self._setup_security_rule_test()
        m_acl.Action = self._utils._ACL_ACTION_DENY
        m_port.associators.return_value = [
            m_acl] * self._utils._REJECT_ACLS_COUNT
        self._utils.create_default_reject_all_rules(self._FAKE_PORT_NAME)

        self.assertFalse(self._utils._remove_virt_feature.called)
        self.assertFalse(self._utils._bind_security_rule.called)

    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._remove_virt_feature')
    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._add_virt_feature')
    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._create_security_acl')
    def test_bind_security_rule(self, mock_create_acl, mock_add, mock_remove):
        (m_port, m_acl) = self._setup_security_rule_test()
        mock_create_acl.return_value = m_acl

        self._utils._bind_security_rule(
            m_port, self._FAKE_ACL_DIR, self._FAKE_ACL_TYPE,
            self._FAKE_ACL_ACT, self._FAKE_LOCAL_PORT, self._FAKE_PROTOCOL,
            self._FAKE_REMOTE_ADDR, self._FAKE_WEIGHT)

        self._utils._add_virt_feature.assert_called_once_with(m_port, m_acl)

    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._remove_virt_feature')
    def test_remove_security_rule(self, mock_remove_feature):
        mock_acl = self._setup_security_rule_test()[1]
        self._utils.remove_security_rule(
            self._FAKE_PORT_NAME, self._FAKE_ACL_DIR, self._FAKE_ACL_TYPE,
            self._FAKE_LOCAL_PORT, self._FAKE_PROTOCOL, self._FAKE_REMOTE_ADDR)
        self._utils._remove_virt_feature.assert_called_once_with(mock_acl)

    @mock.patch('neutron.plugins.hyperv.agent.utilsv2.HyperVUtilsV2'
                '._remove_multiple_virt_features')
    def test_remove_all_security_rules(self, mock_remove_feature):
        mock_acl = self._setup_security_rule_test()[1]
        self._utils.remove_all_security_rules(self._FAKE_PORT_NAME)
        self._utils._remove_multiple_virt_features.assert_called_once_with(
            [mock_acl])

    def _setup_security_rule_test(self):
        mock_port = mock.MagicMock()
        mock_acl = mock.MagicMock()
        mock_port.associators.return_value = [mock_acl]

        self._utils._get_switch_port_allocation = mock.MagicMock(return_value=(
            mock_port, True))
        self._utils._filter_security_acls = mock.MagicMock(
            return_value=[mock_acl])

        return (mock_port, mock_acl)

    def test_filter_acls(self):
        mock_acl = mock.MagicMock()
        mock_acl.Action = self._FAKE_ACL_ACT
        mock_acl.Applicability = self._utils._ACL_APPLICABILITY_LOCAL
        mock_acl.Direction = self._FAKE_ACL_DIR
        mock_acl.AclType = self._FAKE_ACL_TYPE
        mock_acl.RemoteAddress = self._FAKE_REMOTE_ADDR

        acls = [mock_acl, mock_acl]
        good_acls = self._utils._filter_acls(
            acls, self._FAKE_ACL_ACT, self._FAKE_ACL_DIR,
            self._FAKE_ACL_TYPE, self._FAKE_REMOTE_ADDR)
        bad_acls = self._utils._filter_acls(
            acls, self._FAKE_ACL_ACT, self._FAKE_ACL_DIR, self._FAKE_ACL_TYPE)

        self.assertEqual(acls, good_acls)
        self.assertEqual([], bad_acls)


class TestHyperVUtilsV2R2(base.BaseTestCase):
    _FAKE_ACL_ACT = 'fake_acl_action'
    _FAKE_ACL_DIR = 'fake_direction'
    _FAKE_ACL_TYPE = 'fake_acl_type'
    _FAKE_LOCAL_PORT = 'fake_local_port'
    _FAKE_PROTOCOL = 'fake_port_protocol'
    _FAKE_REMOTE_ADDR = '10.0.0.0/0'

    def setUp(self):
        super(TestHyperVUtilsV2R2, self).setUp()
        self._utils = utilsv2.HyperVUtilsV2R2()

    def test_filter_security_acls(self):
        self._test_filter_security_acls(
            self._FAKE_LOCAL_PORT, self._FAKE_PROTOCOL, self._FAKE_REMOTE_ADDR)

    def test_filter_security_acls_default(self):
        default = self._utils._ACL_DEFAULT
        self._test_filter_security_acls(
            default, default, self._FAKE_REMOTE_ADDR)

    def _test_filter_security_acls(self, local_port, protocol, remote_addr):
        acls = []
        default = self._utils._ACL_DEFAULT
        for port, proto in [(default, default), (local_port, protocol)]:
            mock_acl = mock.MagicMock()
            mock_acl.Action = self._utils._ACL_ACTION_ALLOW
            mock_acl.Direction = self._FAKE_ACL_DIR
            mock_acl.LocalPort = port
            mock_acl.Protocol = proto
            mock_acl.RemoteIPAddress = remote_addr
            acls.append(mock_acl)

        right_acls = [a for a in acls if a.LocalPort == local_port]

        good_acls = self._utils._filter_security_acls(
            acls, mock_acl.Action, self._FAKE_ACL_DIR, self._FAKE_ACL_TYPE,
            local_port, protocol, remote_addr)
        bad_acls = self._utils._filter_security_acls(
            acls, self._FAKE_ACL_ACT, self._FAKE_ACL_DIR, self._FAKE_ACL_TYPE,
            local_port, protocol, remote_addr)

        self.assertEqual(right_acls, good_acls)
        self.assertEqual([], bad_acls)

    def test_get_new_weight(self):
        mockacl1 = mock.MagicMock()
        mockacl1.Weight = self._utils._MAX_WEIGHT - 1
        mockacl2 = mock.MagicMock()
        mockacl2.Weight = self._utils._MAX_WEIGHT - 3
        self.assertEqual(self._utils._MAX_WEIGHT - 2,
                         self._utils._get_new_weight([mockacl1, mockacl2]))

    def test_get_new_weight_no_acls(self):
        self.assertEqual(self._utils._MAX_WEIGHT - 1,
                         self._utils._get_new_weight([]))

    def test_get_new_weight_default_acls(self):
        mockacl1 = mock.MagicMock()
        mockacl1.Weight = self._utils._MAX_WEIGHT - 1
        mockacl2 = mock.MagicMock()
        mockacl2.Weight = self._utils._MAX_WEIGHT - 2
        mockacl2.Action = self._utils._ACL_ACTION_DENY

        self.assertEqual(self._utils._MAX_WEIGHT - 2,
                         self._utils._get_new_weight([mockacl1, mockacl2]))
