def test_valid_ports_skips_and_removes_blank_entry(self): expected = [{'protocol': 'TCP', 'port': 456}] under_test = ClcPublicIp(self.module) actual = under_test._validate_ports([{'protocol': 'TCP', 'port': 456}, {}]) self.assertEqual(expected, actual) self.assertFalse(self.module.fail_json.called)
def test_process_request_calls_ensure_public_ip_present_with_expected_args(self, mock_set_clc_creds, mock_public_ip): test_params = { 'server_id': 'TESTSVR1' ,'private_ip': '10.11.12.13' ,'source_restrictions': ['no'] ,'ports': [ {'port': 80}, {'port': 90, 'protocol': 'TCP'} ] ,'wait': True ,'state': 'present' } mock_public_ip.return_value = True, 'TESTSVR1', mock.MagicMock() self.module.params = test_params self.module.check_mode = False under_test = ClcPublicIp(self.module) under_test.process_request() mock_public_ip.assert_called_once_with( server_id='TESTSVR1' , private_ip="10.11.12.13" , ports=[ {'port': 80, 'protocol': 'TCP'}, {'port': 90, 'protocol': 'TCP'} ] , source_restrictions=['no'] ) self.assertFalse(self.module.fail_json.called)
def test_get_servers_from_clc_api(self, mock_clc_sdk): mock_clc_sdk.v2.Servers.side_effect = CLCException("Server Not Found") under_test = ClcPublicIp(self.module) under_test._get_servers_from_clc(['TESTSVR1', 'TESTSVR2'], 'FAILED TO OBTAIN LIST') self.module.fail_json.assert_called_once_with( msg='FAILED TO OBTAIN LIST: Server Not Found')
def test_wait_for_requests_no_wait(self): mock_request = mock.MagicMock() mock_request.WaitUntilComplete.return_value = True self.module.params = {'wait': False} under_test = ClcPublicIp(self.module) under_test._wait_for_requests_to_complete([mock_request]) self.assertFalse(self.module.fail_json.called)
def test_valid_ports_returns_expected_error_for_invalid_protocol(self): under_test = ClcPublicIp(self.module) under_test._validate_ports([{'protocol': 'ICP', 'port': 'Faygo'}]) self.module.fail_json.assert_called_once_with( msg="Valid protocols for this module are: [TCP, UDP]: You specified 'ICP'" )
def test_wait_for_request_w_mock_request(self): mock_r1 = mock.MagicMock() mock_r1.WaitUntilComplete.return_value = True self.module.wait = True under_test = ClcPublicIp(self.module) under_test._wait_for_request_to_complete(mock_r1) self.assertFalse(self.module.fail_json.called)
def test_wait_for_requests_no_wait(self): mock_request = mock.MagicMock() mock_request.WaitUntilComplete.return_value = True self.module.params = { 'wait': False } under_test = ClcPublicIp(self.module) under_test._wait_for_requests_to_complete([mock_request]) self.assertFalse(self.module.fail_json.called)
def test_ensure_server_publicip_present_w_mock_server(self,mock_get_servers): server_ids = ['TESTSVR1'] mock_get_servers.return_value=[mock.MagicMock()] protocol = 'TCP' ports = [80] self.module.check_mode = False under_test = ClcPublicIp(self.module) under_test.ensure_public_ip_present(server_ids, protocol, ports) self.assertFalse(self.module.fail_json.called)
def test_set_clc_credentials_w_token(self): with patch.dict('os.environ', {'CLC_V2_API_TOKEN': 'Token12345', 'CLC_ACCT_ALIAS': 'TEST' }): with patch.object(ClcPublicIp, 'clc') as mock_clc_sdk: under_test = ClcPublicIp(self.module) under_test._set_clc_credentials_from_env() self.assertEqual(mock_clc_sdk._LOGIN_TOKEN_V2, 'Token12345') self.assertFalse(mock_clc_sdk.v2.SetCredentials.called) self.assertEqual(self.module.fail_json.called, False)
def test_ensure_server_publicip_present_w_mock_server( self, mock_get_servers): server_ids = ['TESTSVR1'] mock_get_servers.return_value = [mock.MagicMock()] protocol = 'TCP' ports = [80] self.module.check_mode = False under_test = ClcPublicIp(self.module) under_test.ensure_public_ip_present(server_ids, protocol, ports) self.assertFalse(self.module.fail_json.called)
def test_set_clc_credentials_w_creds(self): with patch.dict('os.environ', { 'CLC_V2_API_USERNAME': '******', 'CLC_V2_API_PASSWD': 'falcon' }): with patch.object(ClcPublicIp, 'clc') as mock_clc_sdk: under_test = ClcPublicIp(self.module) under_test._set_clc_credentials_from_env() mock_clc_sdk.v2.SetCredentials.assert_called_once_with( api_username='******', api_passwd='falcon')
def test_set_clc_credentials_w_token(self): with patch.dict('os.environ', { 'CLC_V2_API_TOKEN': 'Token12345', 'CLC_ACCT_ALIAS': 'TEST' }): with patch.object(ClcPublicIp, 'clc') as mock_clc_sdk: under_test = ClcPublicIp(self.module) under_test._set_clc_credentials_from_env() self.assertEqual(mock_clc_sdk._LOGIN_TOKEN_V2, 'Token12345') self.assertFalse(mock_clc_sdk.v2.SetCredentials.called) self.assertEqual(self.module.fail_json.called, False)
def test_add_publicip_to_server_exception(self, mock_clc_sdk): error = CLCException("Failed") error.response_text = 'Mock failure message' mock_server = mock.MagicMock() mock_server.id = 'TESTSVR1' mock_server.data = {'details': {'ipAddresses': [{'internal': '1.2.3.4'}]}} mock_server.PublicIPs().Add.side_effect = error under_test = ClcPublicIp(self.module) under_test._add_publicip_to_server(mock_server, 'ports') self.module.fail_json.assert_called_once_with( msg='Failed to add public ip to the server : TESTSVR1. Mock failure message')
def test_ensure_server_publicip_present_w_mock_server(self,mock_get_server): server_id = 'TESTSVR1' mock_get_server.return_value=mock.MagicMock() ports = [ {'port': 80}, {'port': 90, 'protocol': 'TCP'} ] self.module.check_mode = False under_test = ClcPublicIp(self.module) under_test.ensure_public_ip_present(server_id, ports) self.assertFalse(self.module.fail_json.called)
def test_wait_for_request_w_mock_request_fail(self): mock_request = mock.MagicMock() mock_request.WaitUntilComplete.return_value = True mock_response = mock.MagicMock() mock_response.Status.return_value = 'Failed' mock_request.requests = [mock_response] self.module.wait = True under_test = ClcPublicIp(self.module) under_test._wait_for_request_to_complete(mock_request) self.assertTrue(self.module.fail_json.called)
def test_wait_for_requests_w_mock_request(self): mock_r1 = mock.MagicMock() mock_r1.WaitUntilComplete.return_value = True mock_r2 = mock.MagicMock() mock_r2.WaitUntilComplete.return_value = True requests = [mock_r1, mock_r2] self.module.wait = True under_test = ClcPublicIp(self.module) under_test._wait_for_requests_to_complete(requests) self.assertFalse(self.module.fail_json.called)
def test_wait_for_requests_w_mock_request_fail(self): mock_request = mock.MagicMock() mock_request.WaitUntilComplete.return_value = True mock_response = mock.MagicMock() mock_response.Status.return_value = 'Failed' mock_request.requests = [mock_response] requests = [mock_request] self.module.wait = True under_test = ClcPublicIp(self.module) under_test._wait_for_requests_to_complete(requests) self.assertTrue(self.module.fail_json.called)
def test_ensure_server_publicip_present_w_mock_server_restrictions(self,mock_get_servers): server_ids = ['TESTSVR1'] mock_get_servers.return_value=[mock.MagicMock()] protocol = 'TCP' ports = [80] restrictions = ['1.1.1.1/24', '2.2.2.0/36'] self.module.check_mode = False under_test = ClcPublicIp(self.module) under_test.ensure_public_ip_present(server_ids=server_ids, protocol=protocol, ports=ports, source_restrictions=restrictions) self.assertFalse(self.module.fail_json.called)
def test_remove_publicip_from_server_exception(self, mock_clc_sdk): error = CLCException("Failed") error.response_text = 'Mock failure message' mock_server = mock.MagicMock() mock_server.id = 'TESTSVR1' ip = mock.MagicMock() ip.ipAddresses = [{'internal': '1.2.3.4'}] ip.Delete.side_effect = error mock_server.data = {'details': ip} mock_server.PublicIPs().public_ips = [ip] under_test = ClcPublicIp(self.module) under_test._remove_publicip_from_server(mock_server) self.module.fail_json.assert_called_once_with( msg='Failed to remove public ip from the server : TESTSVR1. Mock failure message')
def test_ensure_server_publicip_present_w_mock_server_restrictions(self,mock_get_server): server_id = 'TESTSVR1' mock_get_server.return_value=mock.MagicMock() ports = [ {'port': 80}, {'port': 1290, 'protocol': 'UDP'} ] restrictions = ['1.1.1.1/24', '2.2.2.0/36'] self.module.check_mode = False under_test = ClcPublicIp(self.module) under_test.ensure_public_ip_present(server_id=server_id, ports=ports, source_restrictions=restrictions) self.assertFalse(self.module.fail_json.called)
def test_ensure_server_publicip_present_w_mock_server_restrictions( self, mock_get_servers): server_ids = ['TESTSVR1'] mock_get_servers.return_value = [mock.MagicMock()] protocol = 'TCP' ports = [80] restrictions = ['1.1.1.1/24', '2.2.2.0/36'] self.module.check_mode = False under_test = ClcPublicIp(self.module) under_test.ensure_public_ip_present(server_ids=server_ids, protocol=protocol, ports=ports, source_restrictions=restrictions) self.assertFalse(self.module.fail_json.called)
def test_process_request_state_invalid(self, mock_set_clc_creds, mock_public_ip): test_params = { 'server_ids': ['TESTSVR1', 'TESTSVR2'] ,'protocol': 'TCP' ,'ports': [80, 90] ,'wait': True , 'state': 'INVALID' } self.module.params = test_params under_test = ClcPublicIp(self.module) under_test.process_request() self.assertFalse(mock_public_ip.called) self.module.fail_json.assert_called_once_with(msg='Unknown State: INVALID') self.assertFalse(self.module.exit_json.called)
def test_remove_publicip_from_server_exception(self, mock_clc_sdk): error = CLCException("Failed") error.response_text = 'Mock failure message' mock_server = mock.MagicMock() mock_server.id = 'TESTSVR1' ip = mock.MagicMock() ip.ipAddresses = [{'internal': '1.2.3.4'}] ip.Delete.side_effect = error mock_server.data = {'details': ip} mock_server.PublicIPs().public_ips = [ip] under_test = ClcPublicIp(self.module) under_test._remove_publicip_from_server(mock_server) self.module.fail_json.assert_called_once_with( msg= 'Failed to remove public ip from the server : TESTSVR1. Mock failure message' )
def test_ensure_server_absent_absent_w_mock_server(self,mock_get_servers): server_ids = ['TESTSVR1'] mock_server1 = mock.MagicMock() mock_server1.id = 'TESTSVR1' public_ips_obj = mock.MagicMock() ip = mock.MagicMock() ip.Delete.return_value = 'success' public_ips_obj.public_ips = [ip] mock_server1.PublicIPs.return_value = public_ips_obj mock_get_servers.return_value=[mock_server1] self.module.check_mode = False under_test = ClcPublicIp(self.module) changed, servers_modified, requests = under_test.ensure_public_ip_absent(server_ids) self.assertFalse(self.module.fail_json.called) self.assertEqual(changed, True) self.assertEqual(servers_modified, ['TESTSVR1'])
def test_process_request_state_absent(self, mock_set_clc_creds, mock_public_ip): test_params = { 'server_ids': ['TESTSVR1', 'TESTSVR2'] ,'protocol': 'TCP' ,'ports': [80, 90] ,'wait': True , 'state': 'absent' } mock_public_ip.return_value = True, ['TESTSVR1','TESTSVR2'], mock.MagicMock() self.module.params = test_params self.module.check_mode = False under_test = ClcPublicIp(self.module) under_test.process_request() self.module.exit_json.assert_called_once_with(changed=True, server_ids=['TESTSVR1', 'TESTSVR2']) self.assertFalse(self.module.fail_json.called)
def test_process_request_state_invalid(self, mock_set_clc_creds, mock_public_ip): test_params = { 'server_ids': ['TESTSVR1', 'TESTSVR2'], 'protocol': 'TCP', 'ports': [80, 90], 'wait': True, 'state': 'INVALID' } self.module.params = test_params under_test = ClcPublicIp(self.module) under_test.process_request() self.assertFalse(mock_public_ip.called) self.module.fail_json.assert_called_once_with( msg='Unknown State: INVALID') self.assertFalse(self.module.exit_json.called)
def test_ensure_add_public_ip_to_server_calls_sdk_add_with_expected_args(self): mock_server = mock.MagicMock() private_ip = '2.4.6.0.1' ports = [{'protocol': 'UDP', 'port': 8675309}] ports_with_icmp = [{'protocol': 'UDP', 'port': 8675309}] ports_with_icmp.insert(0, {'protocol': 'ICMP', 'port': 0}) restrictions = [{'cidr': 'cider'}] under_test = ClcPublicIp(self.module) under_test._add_publicip_to_server( server=mock_server, private_ip=private_ip, ports_to_expose=ports, source_restrictions=restrictions) mock_server.PublicIPs().Add.assert_called_once_with( ports=ports_with_icmp , private_ip=private_ip , source_restrictions=restrictions )
def test_ensure_server_absent_absent_w_mock_server(self, mock_get_servers): server_ids = ['TESTSVR1'] mock_server1 = mock.MagicMock() mock_server1.id = 'TESTSVR1' public_ips_obj = mock.MagicMock() ip = mock.MagicMock() ip.Delete.return_value = 'success' public_ips_obj.public_ips = [ip] mock_server1.PublicIPs.return_value = public_ips_obj mock_get_servers.return_value = [mock_server1] self.module.check_mode = False under_test = ClcPublicIp(self.module) changed, servers_modified, requests = under_test.ensure_public_ip_absent( server_ids) self.assertFalse(self.module.fail_json.called) self.assertEqual(changed, True) self.assertEqual(servers_modified, ['TESTSVR1'])
def test_valid_ports_returns_expected_output(self): expected = [ {'port': 80, 'protocol': 'TCP'}, {'port': 34590, 'protocol': 'UDP'}, {'port': 1234, 'port_to': 4567, 'protocol': 'TCP'} ] input_data = [ {'port': 80}, {'port': 34590, 'protocol': 'UDP'}, {'port': 1234, 'port_to': 4567} ] under_test = ClcPublicIp(self.module) actual = under_test._validate_ports(input_data) self.assertEqual(expected, actual) self.assertFalse(self.module.fail_json.called)
def test_ensure_server_publicip_present_returns_expected_data(self,mock_get_server): server_id = 'TESTSVR1' mock_server = mock.MagicMock() mock_server.id = server_id mock_server.PublicIPs().Add.return_value = 'Awesome Result' mock_get_server.return_value=mock_server ports = [ {'port': 80}, {'port': 1290, 'protocol': 'UDP'} ] self.module.check_mode = False under_test = ClcPublicIp(self.module) changed, changed_server_id, result = under_test.ensure_public_ip_present(server_id, ports) self.assertEqual(True, changed) self.assertEqual(server_id, changed_server_id) self.assertEqual('Awesome Result', result)
def test_process_request_state_present(self, mock_set_clc_creds, mock_public_ip): test_params = { 'server_ids': ['TESTSVR1', 'TESTSVR2'], 'protocol': 'TCP', 'ports': [80, 90], 'wait': True, 'state': 'present' } mock_public_ip.return_value = True, ['TESTSVR1'], mock.MagicMock() self.module.params = test_params self.module.check_mode = False under_test = ClcPublicIp(self.module) under_test.process_request() self.module.exit_json.assert_called_once_with(changed=True, server_ids=['TESTSVR1']) self.assertFalse(self.module.fail_json.called)
def test_add_publicip_to_server_exception(self, mock_clc_sdk): error = CLCException("Failed") error.response_text = 'Mock failure message' mock_server = mock.MagicMock() mock_server.id = 'TESTSVR1' mock_server.data = { 'details': { 'ipAddresses': [{ 'internal': '1.2.3.4' }] } } mock_server.PublicIPs().Add.side_effect = error under_test = ClcPublicIp(self.module) under_test._add_publicip_to_server(mock_server, 'ports') self.module.fail_json.assert_called_once_with( msg= 'Failed to add public ip to the server : TESTSVR1. Mock failure message' )
def test_ensure_server_publicip_absent_returns_expected_data(self,mock_get_server): server_id = 'TESTSVR1' mock_server = mock.MagicMock() mock_server.id = server_id ip1 = mock.MagicMock() ip2 = mock.MagicMock() ip1.Delete = mock.MagicMock(return_value="Hell0") ip2.Delete = mock.MagicMock(return_value="More Awesome Result") mock_server.PublicIPs().public_ips = [ip1, ip2] mock_get_server.return_value=mock_server self.module.check_mode = False under_test = ClcPublicIp(self.module) changed, changed_server_id, result = under_test.ensure_public_ip_absent(server_id) self.assertEqual(True, changed) self.assertEqual(server_id, changed_server_id) self.assertEqual('More Awesome Result', result)
def test_process_request_validates_valid_ports_argument(self, mock_set_clc_creds, mock_public_ip, mock_validate_ports): test_params = { 'server_id': 'TESTSVR1' ,'ports': [ {'port': 80}, {'port': 34590, 'protocol': 'UDP'} ] ,'wait': True ,'state': 'present' } mock_public_ip.return_value = True, 'TESTSVR1', mock.MagicMock() self.module.params = test_params self.module.check_mode = False under_test = ClcPublicIp(self.module) under_test.process_request() mock_validate_ports.assert_called_once_with(test_params['ports']) self.module.exit_json.assert_called_once_with(changed=True, server_id='TESTSVR1') self.assertFalse(self.module.fail_json.called)
def test_ensure_server_publicip_present_calls_private_helper_with_expected_args(self,mock_get_server,mock_add_ip): server_id = 'TESTSVR1' mock_server = mock.MagicMock() mock_get_server.return_value=mock_server private_ip = '2.4.6.01' ports = [ {'port': 80}, {'port': 1290, 'protocol': 'UDP'} ] restrictions = ['not now'] self.module.check_mode = False under_test = ClcPublicIp(self.module) under_test.ensure_public_ip_present(server_id=server_id, private_ip=private_ip, ports=ports, source_restrictions=restrictions) mock_add_ip.assert_called_once_with( mock_server , ports , private_ip=private_ip , source_restrictions=[{'cidr': restrictions[0]}] )
def test_clc_module_not_found(self): # Setup Mock Import Function real_import = __import__ def mock_import(name, *args): if name == 'clc': raise ImportError return real_import(name, *args) # Under Test with mock.patch('__builtin__.__import__', side_effect=mock_import): reload(clc_publicip) ClcPublicIp(self.module) # Assert Expected Behavior self.module.fail_json.assert_called_with( msg='clc-python-sdk required for this module') reload(clc_publicip)
def test_requests_invalid_version(self): # Setup Mock Import Function real_import = __import__ def mock_import(name, *args): if name == 'requests': args[0]['requests'].__version__ = '2.4.0' return real_import(name, *args) # Under Test with mock.patch('__builtin__.__import__', side_effect=mock_import): reload(clc_publicip) ClcPublicIp(self.module) # Assert Expected Behavior self.module.fail_json.assert_called_with( msg='requests library version should be >= 2.5.0') reload(clc_publicip)
def test_requests_module_not_found(self): # Setup Mock Import Function real_import = __import__ def mock_import(name, *args): if name == 'requests': args[0]['requests'].__version__ = '2.7.0' raise ImportError return real_import(name, *args) # Under Test with mock.patch('__builtin__.__import__', side_effect=mock_import): reload(clc_publicip) ClcPublicIp(self.module) # Assert Expected Behavior self.module.fail_json.assert_called_with( msg='requests library is required for this module') reload(clc_publicip)
def test_set_user_agent(self, mock_clc_sdk): clc_publicip.__version__ = "1" ClcPublicIp._set_user_agent(mock_clc_sdk) self.assertTrue(mock_clc_sdk.SetRequestsSession.called)
def test_valid_ports_returns_expected_error_for_missing_port(self): under_test = ClcPublicIp(self.module) under_test._validate_ports([{'protocol': 'UDP'}]) self.module.fail_json.assert_called_once_with(msg="You must provide a port")
def test_set_clc_credentials_w_creds(self): with patch.dict('os.environ', {'CLC_V2_API_USERNAME': '******', 'CLC_V2_API_PASSWD': 'falcon'}): with patch.object(ClcPublicIp, 'clc') as mock_clc_sdk: under_test = ClcPublicIp(self.module) under_test._set_clc_credentials_from_env() mock_clc_sdk.v2.SetCredentials.assert_called_once_with(api_username='******', api_passwd='falcon')
def test_set_clc_credentials_w_api_url(self, mock_clc_sdk): with patch.dict('os.environ', {'CLC_V2_API_URL': 'dummyapiurl'}): under_test = ClcPublicIp(self.module) under_test._set_clc_credentials_from_env() self.assertEqual(under_test.clc.defaults.ENDPOINT_URL_V2, 'dummyapiurl')
def test_set_clc_credentials_w_no_creds(self): with patch.dict('os.environ', {}, clear=True): under_test = ClcPublicIp(self.module) under_test._set_clc_credentials_from_env() self.assertEqual(self.module.fail_json.called, True)
def test_define_argument_spec(self): result = ClcPublicIp._define_module_argument_spec() self.assertIsInstance(result, dict)
def test_get_servers_from_clc_api(self, mock_clc_sdk): mock_clc_sdk.v2.Servers.side_effect = CLCException("Server Not Found") under_test = ClcPublicIp(self.module) under_test._get_servers_from_clc(['TESTSVR1', 'TESTSVR2'], 'FAILED TO OBTAIN LIST') self.module.fail_json.assert_called_once_with(msg='FAILED TO OBTAIN LIST: Server Not Found')
def test_wait_for_requests_to_complete_req_failed(self): mock_request_list = self.build_mock_publicip_add_request_list( status='failed') under_test = ClcPublicIp(self.module)._wait_for_requests_to_complete under_test(mock_request_list) self.assertTrue(self.module.fail_json.called)