Python clc_loadbalancer.ClcLoadBalancer类代码示例

 def test_ensure_loadbalancerpool_present_no_lb_id(self):
     under_test = ClcLoadBalancer(self.module)
     changed, result, pool_id = under_test.ensure_loadbalancerpool_present(
         None, 'alias', 'location', 'method', 'persistence', 'port')
     self.assertEqual(changed, False)
     self.assertEqual(result, None)
     self.assertEqual(pool_id, None)

    def test_process_request_state_present(self,
                                           mock_set_clc_credentials,
                                           mock_clc_sdk):

        # Setup
        self.module.params = {
            'name': 'test',
            'port': 80,
            'nodes':[{ 'ipAddress': '10.82.152.15', 'privatePort': 80 }],
            'state': 'present'
        }
        mock_loadbalancer_response = [{'name': 'TEST_LB'}]

        mock_clc_sdk.v2.API.Call.side_effect = [
            [{'name': 'test'}],
            {'id': 'test', 'name': 'test'},
            [],
            {'id': 'test', 'name': 'test'},
            []
        ]
        # TODO: Mock a response to API.Call('POST')
        self.module.check_mode = False
        # Under Test
        under_test = ClcLoadBalancer(self.module)
        under_test.process_request()

        # Assert
        self.module.exit_json.assert_called_once_with(changed=False, loadbalancer = {'id': 'test', 'name': 'test'})
        self.assertFalse(self.module.fail_json.called)

 def test_set_loadbalancernodes_exception(self, mock_clc_sdk):
     error = APIFailedResponse('Failed')
     error.response_text = 'Mock failure response'
     mock_clc_sdk.v2.API.Call.side_effect = error
     self.module.check_mode = False
     test = ClcLoadBalancer(self.module)
     result = test.set_loadbalancernodes('alias', 'location', 'lb_id', 'pool_id', [1,2,3])
     self.module.fail_json.assert_called_with(msg='Unable to set nodes for the load balancer pool id "pool_id". Mock failure response')

 def test_create_loadbalancerpool_exception(self, mock_clc_sdk):
     error = APIFailedResponse('Failed')
     error.response_text = 'Mock failure response'
     mock_clc_sdk.v2.API.Call.side_effect = error
     self.module.check_mode = False
     test = ClcLoadBalancer(self.module)
     result = test.create_loadbalancerpool('alias', 'location', 'lb_id', 'method', 'persistance', 'port')
     self.module.fail_json.assert_called_with(msg='Unable to create pool for load balancer id "lb_id". Mock failure response')

 def test_create_loadbalancer_exception(self, mock_clc_sdk):
     error = APIFailedResponse('Failed')
     error.response_text = 'Mock failure response'
     mock_clc_sdk.v2.API.Call.side_effect = error
     self.module.check_mode = False
     test = ClcLoadBalancer(self.module)
     result = test.create_loadbalancer('name', 'alias', 'location', 'description', 'status')
     self.module.fail_json.assert_called_with(msg='Unable to create load balancer "name". Mock failure response')

 def test_loadbalancerpool_exists_exception(self, mock_clc_sdk):
     error = APIFailedResponse('Failed')
     error.response_text = 'Mock failure response'
     mock_clc_sdk.v2.API.Call.side_effect = error
     self.module.check_mode = False
     test = ClcLoadBalancer(self.module)
     test._loadbalancerpool_exists('alias', 'location', 90, 'lb_id')
     self.module.fail_json.assert_called_with(msg='Unable to fetch the load balancer pools for for load balancer id: lb_id. Mock failure response')

 def test_ensure_lbpool_nodes_set_no_lb_pool(self, mock_lb_exists, mock_get_lb, mock_lb_pool_exists):
     mock_lb_exists.return_value = True
     mock_get_lb.return_value = 'lb name'
     mock_lb_pool_exists.return_value = False
     under_test = ClcLoadBalancer(self.module)
     changed, result = under_test.ensure_lbpool_nodes_set('alias', 'location', 'name', 'port', [1,2,3])
     self.assertEqual(changed, False)
     self.assertEqual(result, 'Pool doesn\'t exist')

 def test_set_clc_credentials_from_env(self, mock_clc_sdk):
     with patch.dict('os.environ', {'CLC_V2_API_TOKEN': 'dummyToken',
                                    'CLC_ACCT_ALIAS': 'TEST'}):
         under_test = ClcLoadBalancer(self.module)
         under_test._set_clc_credentials_from_env()
     self.assertEqual(under_test.clc._LOGIN_TOKEN_V2, 'dummyToken')
     self.assertFalse(mock_clc_sdk.v2.SetCredentials.called)
     self.assertEqual(self.module.fail_json.called, False)

 def test_get_loadbalancer_list_exception(self, mock_clc_sdk):
     error = APIFailedResponse('Failed')
     error.response_text = 'Mock failure response'
     mock_clc_sdk.v2.API.Call.side_effect = error
     self.module.check_mode = False
     test = ClcLoadBalancer(self.module)
     test._get_loadbalancer_list('alias', 'location')
     self.module.fail_json.assert_called_with(msg='Unable to fetch load balancers for account: alias. Mock failure response')

 def test_get_lbpool_nodes_exception(self, mock_clc_sdk):
     error = APIFailedResponse('Failed')
     error.response_text = 'Mock failure response'
     mock_clc_sdk.v2.API.Call.side_effect = error
     self.module.check_mode = False
     test = ClcLoadBalancer(self.module)
     result = test._get_lbpool_nodes('alias', 'location', 'lb_id', 'pool_id')
     self.module.fail_json.assert_called_with(msg='Unable to fetch list of available nodes for load balancer pool id: pool_id. Mock failure response')
     self.assertEqual(result, None)

 def test_delete_loadbalancer_exception(self, mock_clc_sdk, mock_get):
     error = APIFailedResponse('Failed')
     error.response_text = 'Mock failure response'
     mock_clc_sdk.v2.API.Call.side_effect = error
     mock_get.return_value = 'lb_id'
     self.module.check_mode = False
     test = ClcLoadBalancer(self.module)
     result = test.delete_loadbalancer('alias', 'location', 'name')
     self.module.fail_json.assert_called_with(msg='Unable to delete load balancer "name". Mock failure response')

 def test_ensure_lbpool_nodes_set(self, set_lb_nodes, lbpool_nodes_exists, lbpool_exists, get_lb_id, lb_exists, mock_clc_sdk):
     lb_exists.return_value = True
     get_lb_id.return_value = '123'
     lbpool_exists.retrun_value = True
     lbpool_nodes_exists.return_value = False
     set_lb_nodes.return_value = 'success'
     self.module.check_mode = False
     test = ClcLoadBalancer(self.module)
     result = test.ensure_lbpool_nodes_set('alias', 'location', 'name', 80, [1,2,3])
     self.assertEqual(result, (True, 'success'))

    def test_set_loadbalancernodes_lb_id_none(self, mock_clc_sdk):

        mock_clc_sdk.v2.API.Call.side_effect = [
            [{'id': 'test', 'name': 'test'}],
            [{'port': '80', 'id':'test'}],
            [{ 'ipAddress': '10.82.152.15', 'privatePort': 81, 'status': 'enabled' }]
        ]
        self.module.check_mode = False
        test = ClcLoadBalancer(self.module)
        result = test.set_loadbalancernodes('alias', 'location', None, 'pool_id', [1,2,3])
        self.assertIsNone(result)

 def test_loadbalancerpool_nodes_exists_false(self, mock_get_pool_nodes, mock_clc_sdk):
     #Setup
     self.module.params = {
         'name': 'test',
         'port': 80,
         'nodes':[{ 'ipAddress': '10.82.152.15', 'privatePort': 80, 'status': 'enabled' }],
         'state': 'nodes_absent'
     }
     self.module.check_mode = False
     test = ClcLoadBalancer(self.module)
     mock_get_pool_nodes.return_value = [{ 'ipAddress': '10.82.152.15', 'privatePort': 80, 'status': 'enabled' }]
     result = test._loadbalancerpool_nodes_exists('alias','location','lb_id','pool_id',
                                    [{ 'ipAddress': '10.82.152.15', 'privatePort': 90}])
     self.assertEqual(result, False)

 def test_remove_lbpool_nodes(self, mock_set_pool_nodes, mock_get_pool_nodes, mock_clc_sdk):
     #Setup
     self.module.params = {
         'name': 'test',
         'port': 80,
         'nodes':[{ 'ipAddress': '10.82.152.15', 'privatePort': 80, 'status': 'enabled' }],
         'state': 'nodes_absent'
     }
     self.module.check_mode = False
     test = ClcLoadBalancer(self.module)
     mock_get_pool_nodes.return_value = [{ 'ipAddress': '10.82.152.15', 'privatePort': 80, 'status': 'enabled' }]
     mock_set_pool_nodes.return_value = 'success'
     result = test.remove_lbpool_nodes('alias','location','lb_id','pool_id',
                                    [{ 'ipAddress': '10.82.152.15', 'privatePort': 80}])
     self.assertFalse(self.module.fail_json.called)
     self.assertEqual(result, (True, 'success'))