"""
    SoftLayer.tests.managers.loadbal_tests
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    :license: MIT, see LICENSE for more details.
"""
import SoftLayer
from SoftLayer import testing

VIRT_IP_SERVICE = ('SoftLayer_Network_Application_Delivery_Controller_'
                   'LoadBalancer_VirtualIpAddress')


class LoadBalancerTests(testing.TestCase):

    def set_up(self):
        self.lb_mgr = SoftLayer.LoadBalancerManager(self.client)

    def test_get_lb_pkgs(self):
        result = self.lb_mgr.get_lb_pkgs()

        self.assertEqual(len(result), 13)
        _filter = {
            'items': {
                'description': {
                    'operation': '*= Load Balancer'
                }
            }
        }
        self.assert_called_with('SoftLayer_Product_Package', 'getItems',
                                identifier=0,
                                filter=_filter)

    def test_get_hc_types(self):
        result = self.lb_mgr.get_hc_types()

        self.assertEqual(len(result), 6)
        service = ('SoftLayer_Network_Application_Delivery_Controller_'
                   'LoadBalancer_Health_Check_Type')
        self.assert_called_with(service, 'getAllObjects')

    def test_get_routing_methods(self):
        result = self.lb_mgr.get_routing_methods()

        self.assertEqual(len(result), 12)
        service = ('SoftLayer_Network_Application_Delivery_Controller_'
                   'LoadBalancer_Routing_Method')
        self.assert_called_with(service, 'getAllObjects')

    def test_get_location(self):
        id1 = self.lb_mgr._get_location('sjc01')
        self.assertEqual(id1, 168642)

        id2 = self.lb_mgr._get_location('dal05')
        self.assertEqual(id2, 'FIRST_AVAILABLE')

    def test_get_routing_types(self):
        result = self.lb_mgr.get_routing_types()

        self.assertEqual(len(result), 6)
        service = ('SoftLayer_Network_Application_Delivery_Controller_'
                   'LoadBalancer_Routing_Type')
        self.assert_called_with(service, 'getAllObjects')

    def test_cancel_lb(self):
        result = self.lb_mgr.cancel_lb(6327)

        self.assertEqual(result, True)
        self.assert_called_with('SoftLayer_Billing_Item', 'cancelService',
                                identifier=21370814)

    def test_add_local_lb(self):
        self.lb_mgr.add_local_lb(6327, 'sjc01')

        args = ({
            'complexType': 'SoftLayer_Container_Product_Order_Network_'
                           'LoadBalancer',
            'quantity': 1,
            'packageId': 0,
            "location": 168642,
            'prices': [{'id': 6327}]
        },)
        self.assert_called_with('SoftLayer_Product_Order', 'placeOrder',
                                args=args)

    def test_get_local_lbs(self):
        result = self.lb_mgr.get_local_lbs()

        self.assertEqual(len(result), 0)
        mask = 'mask[loadBalancerHardware[datacenter],ipAddress]'
        self.assert_called_with('SoftLayer_Account', 'getAdcLoadBalancers',
                                mask=mask)

    def test_get_local_lb(self):
        result = self.lb_mgr.get_local_lb(22348)

        self.assertEqual(result['id'], 22348)
        mask = ('mask['
                'loadBalancerHardware[datacenter], '
                'ipAddress, virtualServers[serviceGroups'
                '[routingMethod,routingType,services'
                '[healthChecks[type], groupReferences,'
                ' ipAddress]]]]')
        self.assert_called_with(VIRT_IP_SERVICE, 'getObject',
                                identifier=22348,
                                mask=mask)

    def test_delete_service(self):
        result = self.lb_mgr.delete_service(1234)

        self.assertEqual(result, True)
        service = ('SoftLayer_Network_Application_Delivery_Controller_'
                   'LoadBalancer_Service')
        self.assert_called_with(service, 'deleteObject', identifier=1234)

    def test_delete_service_group(self):
        result = self.lb_mgr.delete_service_group(1234)

        self.assertEqual(result, True)
        service = ('SoftLayer_Network_Application_Delivery_Controller_'
                   'LoadBalancer_VirtualServer')
        self.assert_called_with(service, 'deleteObject', identifier=1234)

    def test_toggle_service_status(self):
        result = self.lb_mgr.toggle_service_status(1234)

        self.assertEqual(result, True)
        service = ('SoftLayer_Network_Application_Delivery_Controller_'
                   'LoadBalancer_Service')
        self.assert_called_with(service, 'toggleStatus', identifier=1234)

    def test_edit_service(self):
        self.lb_mgr.edit_service(12345, 1234, '9.9.9.9', 80, True, 21, 1)

        _filter = {
            'virtualServers': {
                'serviceGroups': {
                    'services': {
                        'id': {
                            'operation': 1234
                        }
                    }
                }
            }
        }
        mask = 'mask[serviceGroups[services[groupReferences,healthChecks]]]'
        self.assert_called_with(VIRT_IP_SERVICE, 'getVirtualServers',
                                identifier=12345,
                                filter=_filter,
                                mask=mask)

        self.assert_called_with(VIRT_IP_SERVICE, 'editObject')

    def test_add_service(self):
        self.lb_mgr.add_service(12345, 50718, 123, 80, True, 21, 1)

        mask = 'mask[virtualServers[serviceGroups[services[groupReferences]]]]'
        self.assert_called_with(VIRT_IP_SERVICE, 'getObject',
                                mask=mask,
                                identifier=12345)

        self.assert_called_with(VIRT_IP_SERVICE, 'editObject',
                                identifier=12345)
        arg = self.calls(VIRT_IP_SERVICE, 'editObject')[0].args[0]
        self.assertEqual(
            len(arg['virtualServers'][0]['serviceGroups'][0]['services']),
            2)

    def test_edit_service_group(self):
        self.lb_mgr.edit_service_group(12345,
                                       group_id=50718,
                                       allocation=100,
                                       port=80,
                                       routing_type=2,
                                       routing_method=10)

        mask = 'mask[virtualServers[serviceGroups[services[groupReferences]]]]'
        self.assert_called_with(VIRT_IP_SERVICE, 'getObject',
                                identifier=12345,
                                mask=mask)

        self.assert_called_with(VIRT_IP_SERVICE, 'getObject', identifier=12345)

    def test_add_service_group(self):
        self.lb_mgr.add_service_group(12345, 100, 80, 2, 10)

        mask = 'mask[virtualServers[serviceGroups[services[groupReferences]]]]'
        self.assert_called_with(VIRT_IP_SERVICE, 'getObject',
                                mask=mask,
                                identifier=12345)

        self.assert_called_with(VIRT_IP_SERVICE, 'editObject',
                                identifier=12345)
        arg = self.calls(VIRT_IP_SERVICE, 'editObject')[0].args[0]
        self.assertEqual(len(arg['virtualServers']), 2)

    def test_reset_service_group(self):
        result = self.lb_mgr.reset_service_group(12345, group_id=50718)

        self.assertEqual(result, True)
        _filter = {'virtualServers': {'id': {'operation': 50718}}}
        self.assert_called_with(VIRT_IP_SERVICE, 'getVirtualServers',
                                identifier=12345,
                                filter=_filter,
                                mask='mask[serviceGroups]')

        service = ('SoftLayer_Network_Application_Delivery_Controller_'
                   'LoadBalancer_Service_Group')
        self.assert_called_with(service, 'kickAllConnections',
                                identifier=51758)