def test_modify_network_interface_attribute(self):
self.set_mock_db_items(fakes.DB_NETWORK_INTERFACE_1,
fakes.DB_NETWORK_INTERFACE_2)
self.execute(
'ModifyNetworkInterfaceAttribute', {
'NetworkInterfaceId': fakes.ID_EC2_NETWORK_INTERFACE_1,
'Description.Value': 'New description'
})
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.update_dict(fakes.DB_NETWORK_INTERFACE_1,
{'description': 'New description'}))
self.db_api.reset_mock()
self.execute(
'ModifyNetworkInterfaceAttribute', {
'NetworkInterfaceId':
fakes.ID_EC2_NETWORK_INTERFACE_2,
'Attachment.AttachmentId':
(fakes.ID_EC2_NETWORK_INTERFACE_2_ATTACH),
'Attachment.DeleteOnTermination':
'True'
})
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.update_dict(fakes.DB_NETWORK_INTERFACE_2,
{'delete_on_termination': True}))
def test_stop_gateway_vpn_connections(self, stop_vpn_connection):
context = base.create_context()
cleaner = common.OnCrashCleaner()
vpn_connection_3 = tools.update_dict(
fakes.DB_VPN_CONNECTION_1, {"id": fakes.random_ec2_id("vpn"), "os_ipsec_site_connections": {}}
)
self.set_mock_db_items(fakes.DB_VPN_CONNECTION_1, vpn_connection_3, fakes.DB_VPN_CONNECTION_2)
vpn_connection_api._stop_gateway_vpn_connections(context, self.neutron, cleaner, fakes.DB_VPN_GATEWAY_1)
self.assertEqual(2, stop_vpn_connection.call_count)
stop_vpn_connection.assert_any_call(self.neutron, fakes.DB_VPN_CONNECTION_1)
stop_vpn_connection.assert_any_call(self.neutron, vpn_connection_3)
self.assertEqual(2, self.db_api.update_item.call_count)
self.db_api.update_item.assert_any_call(
mock.ANY, tools.update_dict(fakes.DB_VPN_CONNECTION_1, {"os_ipsec_site_connections": {}})
)
self.db_api.update_item.assert_any_call(mock.ANY, vpn_connection_3)
self.db_api.reset_mock()
self.neutron.reset_mock()
stop_vpn_connection.reset_mock()
self.set_mock_db_items(fakes.DB_VPN_CONNECTION_1)
try:
with common.OnCrashCleaner() as cleaner:
vpn_connection_api._stop_gateway_vpn_connections(context, self.neutron, cleaner, fakes.DB_VPN_GATEWAY_1)
raise Exception("fake-exception")
except Exception as ex:
if ex.message != "fake-exception":
raise
self.db_api.update_item.assert_called_with(mock.ANY, fakes.DB_VPN_CONNECTION_1)
def test_attach_vpn_gateway_invalid_parameters(self):
def do_check(error_code):
self.assert_execution_error(
error_code, 'AttachVpnGateway',
{'VpcId': fakes.ID_EC2_VPC_2,
'VpnGatewayId': fakes.ID_EC2_VPN_GATEWAY_2})
self.assertFalse(self.db_api.update_item.called)
self.db_api.reset_mock()
self.set_mock_db_items(fakes.DB_VPC_2)
do_check('InvalidVpnGatewayID.NotFound')
self.set_mock_db_items(fakes.DB_VPN_GATEWAY_2)
do_check('InvalidVpcID.NotFound')
self.set_mock_db_items(
tools.update_dict(fakes.DB_VPN_GATEWAY_2,
{'vpc_id': fakes.ID_EC2_VPC_1}),
fakes.DB_VPC_2)
do_check('VpnGatewayAttachmentLimitExceeded')
self.set_mock_db_items(
fakes.DB_VPN_GATEWAY_2, fakes.DB_VPC_2,
tools.update_dict(fakes.DB_VPN_GATEWAY_1,
{'vpc_id': fakes.ID_EC2_VPC_2}))
do_check('InvalidVpcState')
def setUp(self):
super(VpnGatewayTestCase, self).setUp()
self.DB_VPN_GATEWAY_2_ATTACHED = tools.update_dict(
fakes.DB_VPN_GATEWAY_2, {'vpc_id': fakes.ID_EC2_VPC_2})
self.DB_VPN_GATEWAY_1_DETACHED = tools.update_dict(
fakes.DB_VPN_GATEWAY_1, {'vpc_id': None})
self.DB_SUBNET_1_NO_VPN = tools.purge_dict(
fakes.DB_SUBNET_1, ('os_vpnservice_id',))
def test_update_dict(self):
d1 = {'a': 1, 'b': 2}
d2 = {'b': 22, 'c': 33}
res = tools.update_dict(d1, {})
self.assertEqual({'a': 1, 'b': 2}, res)
res = tools.update_dict(d1, d2)
self.assertEqual({'a': 1, 'b': 22, 'c': 33}, res)
self.assertEqual({'a': 1, 'b': 2}, d1)
def test_associate_address_vpc(self):
address.address_engine = (
address.AddressEngineNeutron())
def do_check(params, fixed_ip):
resp = self.execute('AssociateAddress', params)
self.assertEqual(True, resp['return'])
self.assertEqual(fakes.ID_EC2_ASSOCIATION_1, resp['associationId'])
self.neutron.update_floatingip.assert_called_once_with(
fakes.ID_OS_FLOATING_IP_1,
{'floatingip': {'port_id': fakes.ID_OS_PORT_2,
'fixed_ip_address': fixed_ip}})
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.update_dict(
fakes.DB_ADDRESS_1,
{'network_interface_id':
fakes.ID_EC2_NETWORK_INTERFACE_2,
'private_ip_address': fixed_ip}))
self.neutron.update_floatingip.reset_mock()
self.db_api.update_item.reset_mock()
self.set_mock_db_items(
fakes.DB_ADDRESS_1, fakes.DB_IGW_1, fakes.DB_IGW_2,
fakes.DB_NETWORK_INTERFACE_1, fakes.DB_NETWORK_INTERFACE_2)
self.neutron.show_floatingip.return_value = (
{'floatingip': fakes.OS_FLOATING_IP_1})
do_check({'AllocationId': fakes.ID_EC2_ADDRESS_1,
'InstanceId': fakes.ID_EC2_INSTANCE_1},
fakes.IP_NETWORK_INTERFACE_2)
do_check({'AllocationId': fakes.ID_EC2_ADDRESS_1,
'NetworkInterfaceId': fakes.ID_EC2_NETWORK_INTERFACE_2},
fakes.IP_NETWORK_INTERFACE_2)
do_check({'AllocationId': fakes.ID_EC2_ADDRESS_1,
'NetworkInterfaceId': fakes.ID_EC2_NETWORK_INTERFACE_2,
'PrivateIpAddress': fakes.IP_NETWORK_INTERFACE_2_EXT_1},
fakes.IP_NETWORK_INTERFACE_2_EXT_1)
assigned_db_address_1 = tools.update_dict(
fakes.DB_ADDRESS_1,
{'network_interface_id': fakes.ID_EC2_NETWORK_INTERFACE_1,
'private_ip_address': fakes.IP_NETWORK_INTERFACE_1})
self.add_mock_db_items(assigned_db_address_1)
assigned_floating_ip_1 = tools.update_dict(
fakes.OS_FLOATING_IP_1,
{'fixed_port_id': fakes.ID_OS_PORT_1,
'fixed_ip_address': fakes.IP_NETWORK_INTERFACE_1})
self.neutron.show_floatingip.return_value = (
{'floatingip': assigned_floating_ip_1})
do_check({'AllocationId': fakes.ID_EC2_ADDRESS_1,
'InstanceId': fakes.ID_EC2_INSTANCE_1,
'AllowReassociation': 'True'},
fakes.IP_NETWORK_INTERFACE_2)
def test_associate_address_vpc(self):
address.address_engine = (
address.AddressEngineNeutron())
def do_check(params, fixed_ip):
resp = self.execute('AssociateAddress', params)
self.assertEqual(True, resp['return'])
self.assertEqual(fakes.ID_EC2_ASSOCIATION_1, resp['associationId'])
self.neutron.update_floatingip.assert_called_once_with(
fakes.ID_OS_FLOATING_IP_1,
{'floatingip': {'port_id': fakes.ID_OS_PORT_2,
'fixed_ip_address': fixed_ip}})
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.update_dict(
fakes.DB_ADDRESS_1,
{'network_interface_id':
fakes.ID_EC2_NETWORK_INTERFACE_2,
'private_ip_address': fixed_ip}))
self.neutron.update_floatingip.reset_mock()
self.db_api.update_item.reset_mock()
self.set_mock_db_items(
fakes.DB_ADDRESS_1, fakes.DB_IGW_1, fakes.DB_IGW_2,
fakes.DB_NETWORK_INTERFACE_1, fakes.DB_NETWORK_INTERFACE_2)
self.neutron.show_floatingip.return_value = (
{'floatingip': fakes.OS_FLOATING_IP_1})
do_check({'AllocationId': fakes.ID_EC2_ADDRESS_1,
'InstanceId': fakes.ID_EC2_INSTANCE_1},
fakes.IP_NETWORK_INTERFACE_2)
do_check({'AllocationId': fakes.ID_EC2_ADDRESS_1,
'NetworkInterfaceId': fakes.ID_EC2_NETWORK_INTERFACE_2},
fakes.IP_NETWORK_INTERFACE_2)
do_check({'AllocationId': fakes.ID_EC2_ADDRESS_1,
'NetworkInterfaceId': fakes.ID_EC2_NETWORK_INTERFACE_2,
'PrivateIpAddress': fakes.IP_NETWORK_INTERFACE_2_EXT_1},
fakes.IP_NETWORK_INTERFACE_2_EXT_1)
assigned_db_address_1 = tools.update_dict(
fakes.DB_ADDRESS_1,
{'network_interface_id': fakes.ID_EC2_NETWORK_INTERFACE_1,
'private_ip_address': fakes.IP_NETWORK_INTERFACE_1})
self.add_mock_db_items(assigned_db_address_1)
assigned_floating_ip_1 = tools.update_dict(
fakes.OS_FLOATING_IP_1,
{'fixed_port_id': fakes.ID_OS_PORT_1,
'fixed_ip_address': fakes.IP_NETWORK_INTERFACE_1})
self.neutron.show_floatingip.return_value = (
{'floatingip': assigned_floating_ip_1})
do_check({'AllocationId': fakes.ID_EC2_ADDRESS_1,
'InstanceId': fakes.ID_EC2_INSTANCE_1,
'AllowReassociation': 'True'},
fakes.IP_NETWORK_INTERFACE_2)
def test_attach_vpn_gateway(self):
self.configure(external_network=fakes.NAME_OS_PUBLIC_NETWORK)
subnet_2 = tools.patch_dict(fakes.DB_SUBNET_2,
{'vpc_id': fakes.ID_EC2_VPC_2},
('os_vpnservice_id',))
self.set_mock_db_items(
fakes.DB_VPN_GATEWAY_1, fakes.DB_VPN_GATEWAY_2,
fakes.DB_VPC_2, fakes.DB_IGW_1, fakes.DB_IGW_2,
fakes.DB_SUBNET_1, subnet_2)
subnet_2_updated = tools.update_dict(
subnet_2, {'os_vpnservice_id': fakes.ID_OS_VPNSERVICE_2})
os_vpnservice_2 = tools.patch_dict(fakes.OS_VPNSERVICE_2,
{'router_id': fakes.ID_OS_ROUTER_2},
('id',))
self.neutron.list_networks.return_value = (
{'networks': [{'id': fakes.ID_OS_PUBLIC_NETWORK}]})
self.neutron.create_vpnservice.side_effect = tools.get_neutron_create(
'vpnservice', fakes.ID_OS_VPNSERVICE_2)
def do_check():
resp = self.execute('AttachVpnGateway',
{'VpcId': fakes.ID_EC2_VPC_2,
'VpnGatewayId': fakes.ID_EC2_VPN_GATEWAY_2})
self.assertEqual({'attachment': {'state': 'attached',
'vpcId': fakes.ID_EC2_VPC_2}},
resp)
self.assertEqual(2, self.db_api.update_item.call_count)
self.db_api.update_item.assert_has_calls(
[mock.call(mock.ANY, self.DB_VPN_GATEWAY_2_ATTACHED),
mock.call(mock.ANY, subnet_2_updated)])
self.neutron.create_vpnservice.assert_called_once_with(
{'vpnservice': os_vpnservice_2})
do_check()
self.neutron.add_gateway_router.assert_called_once_with(
fakes.ID_OS_ROUTER_2,
{'network_id': fakes.ID_OS_PUBLIC_NETWORK})
self.neutron.list_networks.assert_called_once_with(
**{'router:external': True,
'name': fakes.NAME_OS_PUBLIC_NETWORK})
# Internet gateway is already attached
self.db_api.reset_mock()
self.neutron.reset_mock()
igw_2 = tools.update_dict(fakes.DB_IGW_2,
{'vpc_id': fakes.ID_EC2_VPC_2})
self.add_mock_db_items(igw_2)
do_check()
self.neutron.add_gateway_router.assert_not_called()
def test_associate_dhcp_options_rollback(self):
vpc = tools.update_dict(
fakes.DB_VPC_1, {'dhcp_options_id': fakes.ID_EC2_DHCP_OPTIONS_1})
self.set_mock_db_items(vpc, fakes.DB_DHCP_OPTIONS_1,
fakes.DB_DHCP_OPTIONS_2,
fakes.DB_NETWORK_INTERFACE_1,
fakes.DB_NETWORK_INTERFACE_2)
self.neutron.list_ports.return_value = ({
'ports': [fakes.OS_PORT_1, fakes.OS_PORT_2]
})
def update_port_func(port_id, _port_data):
if port_id == fakes.ID_OS_PORT_2:
raise Exception()
self.neutron.update_port.side_effect = update_port_func
self.assert_execution_error(
self.ANY_EXECUTE_ERROR, 'AssociateDhcpOptions', {
'dhcpOptionsId': fakes.ID_EC2_DHCP_OPTIONS_2,
'vpcId': fakes.ID_EC2_VPC_1
})
self.assert_any_call(self.neutron.update_port, fakes.ID_OS_PORT_1,
{'port': fakes.OS_DHCP_OPTIONS_1})
self.db_api.update_item.assert_any_call(mock.ANY, vpc)
def test_associate_dhcp_options_rollback(self):
vpc = tools.update_dict(
fakes.DB_VPC_1,
{'dhcp_options_id': fakes.ID_EC2_DHCP_OPTIONS_1})
self.set_mock_db_items(
vpc, fakes.DB_DHCP_OPTIONS_1, fakes.DB_DHCP_OPTIONS_2,
fakes.DB_NETWORK_INTERFACE_1, fakes.DB_NETWORK_INTERFACE_2)
self.neutron.list_ports.return_value = (
{'ports': [fakes.OS_PORT_1, fakes.OS_PORT_2]})
def update_port_func(port_id, _port_data):
if port_id == fakes.ID_OS_PORT_2:
raise Exception()
self.neutron.update_port.side_effect = update_port_func
self.assert_execution_error(
self.ANY_EXECUTE_ERROR, 'AssociateDhcpOptions',
{'dhcpOptionsId': fakes.ID_EC2_DHCP_OPTIONS_2,
'vpcId': fakes.ID_EC2_VPC_1})
self.assert_any_call(self.neutron.update_port,
fakes.ID_OS_PORT_1,
{'port': fakes.OS_DHCP_OPTIONS_1})
self.db_api.update_item.assert_any_call(
mock.ANY, vpc)
def test_attach_igw(self):
self.configure(external_network=fakes.NAME_OS_PUBLIC_NETWORK)
self.set_mock_db_items(fakes.DB_IGW_1, fakes.DB_IGW_2, fakes.DB_VPC_2,
fakes.DB_VPN_GATEWAY_1, fakes.DB_VPN_GATEWAY_2)
self.neutron.list_networks.return_value = (
{'networks': [{'id': fakes.ID_OS_PUBLIC_NETWORK}]})
def do_check():
resp = self.execute(
'AttachInternetGateway',
{'VpcId': fakes.ID_EC2_VPC_2,
'InternetGatewayId': fakes.ID_EC2_IGW_2})
self.assertEqual(True, resp['return'])
self.db_api.update_item.assert_called_once_with(
mock.ANY, self.DB_IGW_2_ATTACHED)
do_check()
self.neutron.add_gateway_router.assert_called_once_with(
fakes.ID_OS_ROUTER_2,
{'network_id': fakes.ID_OS_PUBLIC_NETWORK})
self.neutron.list_networks.assert_called_once_with(
**{'router:external': True,
'name': fakes.NAME_OS_PUBLIC_NETWORK})
# VPN gateway is already attached
self.db_api.reset_mock()
self.neutron.reset_mock()
vgw_2 = tools.update_dict(fakes.DB_VPN_GATEWAY_2,
{'vpc_id': fakes.ID_EC2_VPC_2})
self.add_mock_db_items(vgw_2)
do_check()
self.assertFalse(self.neutron.add_gateway_router.called)
def do_check():
resp = self.execute(
'DetachVpnGateway',
{'VpcId': fakes.ID_EC2_VPC_1,
'VpnGatewayId': fakes.ID_EC2_VPN_GATEWAY_1})
self.assertEqual({'return': True}, resp)
self.assertEqual(3, self.db_api.update_item.call_count)
self.db_api.update_item.assert_has_calls(
[mock.call(mock.ANY, self.DB_VPN_GATEWAY_1_DETACHED),
mock.call(mock.ANY,
tools.update_dict(
fakes.DB_VPN_CONNECTION_1,
{'os_ipsec_site_connections': {}})),
mock.call(mock.ANY, self.DB_SUBNET_1_NO_VPN)])
self.neutron.delete_vpnservice.assert_called_once_with(
fakes.ID_OS_VPNSERVICE_1)
self.assertEqual(1, len(delete_vpnservice_calls))
self.assertEqual(
mock.call(mock.ANY, self.neutron, mock.ANY, fakes.DB_SUBNET_1),
delete_vpnservice_calls[0])
self.assertIsInstance(delete_vpnservice_calls[0][1][2],
common.OnCrashCleaner)
stop_gateway_vpn_connections.assert_called_once_with(
mock.ANY, self.neutron, mock.ANY,
self.DB_VPN_GATEWAY_1_DETACHED)
self.assertIsInstance(stop_gateway_vpn_connections.call_args[0][2],
common.OnCrashCleaner)
self.neutron.delete_ipsec_site_connection.assert_called_once_with(
fakes.ID_OS_IPSEC_SITE_CONNECTION_2)
mock_manager.assert_has_calls([
mock.call.stop_gateway_vpn_connections(
*(mock.ANY for _x in range(4))),
mock.call.delete_vpnservice(
*(mock.ANY for _x in range(4)))])
def test_describe_vpn_connections(self):
self.set_mock_db_items(
fakes.DB_VPN_CONNECTION_1,
fakes.DB_VPN_CONNECTION_2,
fakes.DB_CUSTOMER_GATEWAY_1,
fakes.DB_CUSTOMER_GATEWAY_2,
fakes.DB_VPN_GATEWAY_1,
fakes.DB_VPN_GATEWAY_2,
fakes.DB_VPC_1,
fakes.DB_VPC_2,
)
self.neutron.list_ikepolicies.return_value = {"ikepolicies": [fakes.OS_IKEPOLICY_1, fakes.OS_IKEPOLICY_2]}
self.neutron.list_ipsecpolicies.return_value = {
"ipsecpolicies": [fakes.OS_IPSECPOLICY_1, fakes.OS_IPSECPOLICY_2]
}
self.neutron.list_ipsec_site_connections.return_value = {"ipsec_site_connections": []}
self.neutron.list_routers.return_value = {"routers": [fakes.OS_ROUTER_1, fakes.OS_ROUTER_2]}
resp = self.execute("DescribeVpnConnections", {})
vpns = [
tools.update_dict(vpn, {"customerGatewayConfiguration": "DONTCARE"})
for vpn in (fakes.EC2_VPN_CONNECTION_1, fakes.EC2_VPN_CONNECTION_2)
]
self.assertThat(resp, matchers.DictMatches({"vpnConnectionSet": vpns}, orderless_lists=True))
for vpn in (fakes.EC2_VPN_CONNECTION_1, fakes.EC2_VPN_CONNECTION_2):
config = next(
v["customerGatewayConfiguration"]
for v in resp["vpnConnectionSet"]
if v["vpnConnectionId"] == vpn["vpnConnectionId"]
)
self.assertThat(config, matchers.XMLMatches(vpn["customerGatewayConfiguration"], orderless_sequence=True))
self.assertTrue(config.startswith("<?xml version='1.0' encoding='UTF-8'?>"))
self.neutron.list_ikepolicies.assert_called_once_with(tenant_id=fakes.ID_OS_PROJECT)
self.neutron.list_ipsecpolicies.assert_called_once_with(tenant_id=fakes.ID_OS_PROJECT)
self.neutron.list_ipsec_site_connections.assert_called_once_with(tenant_id=fakes.ID_OS_PROJECT)
self.neutron.list_routers.assert_called_once_with(tenant_id=fakes.ID_OS_PROJECT)
resp = self.execute("DescribeVpnConnections", {"VpnConnectionId.1": fakes.ID_EC2_VPN_CONNECTION_1})
self.assertThat(resp, matchers.DictMatches({"vpnConnectionSet": [vpns[0]]}, orderless_lists=True))
self.check_filtering(
"DescribeVpnConnections",
"vpnConnectionSet",
[
("customer-gateway-configuration", "*" + fakes.PRE_SHARED_KEY_1 + "*"),
("customer-gateway-id", fakes.ID_EC2_CUSTOMER_GATEWAY_1),
("state", "available"),
("option.static-routes-only", True),
("route.destination-cidr-block", fakes.CIDR_VPN_2_PROPAGATED_1),
("type", "ipsec.1"),
("vpn-connection-id", fakes.ID_EC2_VPN_CONNECTION_1),
("vpn-gateway-id", fakes.ID_EC2_VPN_GATEWAY_1),
],
)
self.check_tag_support(
"DescribeVpnConnections", "vpnConnectionSet", fakes.ID_EC2_VPN_CONNECTION_1, "vpnConnectionId"
)
def test_delete_dhcp_options_with_dependencies(self):
self.set_mock_db_items(
fakes.DB_DHCP_OPTIONS_1,
tools.update_dict(
fakes.DB_VPC_1,
{'dhcp_options_id': fakes.ID_EC2_DHCP_OPTIONS_1}))
self.assert_execution_error(
'DependencyViolation', 'DeleteDhcpOptions',
{'dhcpOptionsId': fakes.ID_EC2_DHCP_OPTIONS_1})
def test_delete_dhcp_options_with_dependencies(self):
self.set_mock_db_items(
fakes.DB_DHCP_OPTIONS_1,
tools.update_dict(
fakes.DB_VPC_1,
{'dhcp_options_id': fakes.ID_EC2_DHCP_OPTIONS_1}))
self.assert_execution_error(
'DependencyViolation', 'DeleteDhcpOptions',
{'dhcpOptionsId': fakes.ID_EC2_DHCP_OPTIONS_1})
def test_format_vpn_connection(self):
db_vpn_connection_1 = tools.update_dict(fakes.DB_VPN_CONNECTION_1, {"cidrs": []})
ec2_vpn_connection_1 = tools.patch_dict(
fakes.EC2_VPN_CONNECTION_1, {"routes": [], "vgwTelemetry": []}, ("customerGatewayConfiguration",)
)
formatted = vpn_connection_api._format_vpn_connection(
db_vpn_connection_1, {fakes.ID_EC2_CUSTOMER_GATEWAY_1: fakes.DB_CUSTOMER_GATEWAY_1}, {}, {}, {}, {}
)
formatted.pop("customerGatewayConfiguration")
self.assertThat(ec2_vpn_connection_1, matchers.DictMatches(formatted))
def _compare_aws_xml(self, root_tag, xmlns, request_id, dict_data,
observed):
# NOTE(ft): we cann't use matchers.XMLMatches since it makes comparison
# based on the order of tags
xml = etree.fromstring(observed)
self.assertEqual(xmlns, xml.nsmap.get(None))
observed_data = tools.parse_xml(observed)
expected = {root_tag: tools.update_dict(dict_data,
{'requestId': request_id})}
self.assertThat(observed_data, matchers.DictMatches(expected))
def _compare_aws_xml(self, root_tag, xmlns, request_id, dict_data,
observed):
# NOTE(ft): we cann't use matchers.XMLMatches since it makes comparison
# based on the order of tags
xml = etree.fromstring(observed)
self.assertEqual(xmlns, xml.nsmap.get(None))
observed_data = tools.parse_xml(observed)
expected = {root_tag: tools.update_dict(dict_data,
{'requestId': request_id})}
self.assertThat(observed_data, matchers.DictMatches(expected))
def test_detach_network_interface_rollback(self):
network_interface = tools.update_dict(fakes.DB_NETWORK_INTERFACE_2,
{'device_index': 1})
self.set_mock_db_items(network_interface)
self.neutron.show_port.return_value = ({'port': fakes.OS_PORT_2})
self.neutron.update_port.side_effect = Exception()
self.assert_execution_error(
self.ANY_EXECUTE_ERROR, 'DetachNetworkInterface',
{'AttachmentId': fakes.ID_EC2_NETWORK_INTERFACE_2_ATTACH})
self.db_api.update_item.assert_any_call(mock.ANY, network_interface)
def test_delete_subnet_vpn(self):
context = base.create_context()
cleaner = common.OnCrashCleaner()
# subnet is not connected to the vpn
vpn_connection_api._delete_subnet_vpn(context, self.neutron, cleaner,
fakes.DB_SUBNET_1,
fakes.DB_VPN_CONNECTION_1)
self.assertFalse(self.db_api.update_item.called)
self.assertFalse(self.neutron.delete_ipsec_site_connection.called)
# delete subnet vpn connection
vpn_connection_api._delete_subnet_vpn(
context, self.neutron, cleaner, fakes.DB_SUBNET_2,
copy.deepcopy(fakes.DB_VPN_CONNECTION_1))
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.update_dict(fakes.DB_VPN_CONNECTION_1,
{'os_ipsec_site_connections': {}}))
self.neutron.delete_ipsec_site_connection.assert_called_once_with(
fakes.ID_OS_IPSEC_SITE_CONNECTION_2)
# delete subnet vpn connection, leave connections of other subnets
self.db_api.reset_mock()
self.neutron.reset_mock()
id_os_connection = fakes.random_os_id()
vpn_connection_1 = copy.deepcopy(fakes.DB_VPN_CONNECTION_1)
(vpn_connection_1['os_ipsec_site_connections'][fakes.ID_EC2_SUBNET_1]
) = id_os_connection
vpn_connection_api._delete_subnet_vpn(context, self.neutron, cleaner,
fakes.DB_SUBNET_1,
vpn_connection_1)
self.db_api.update_item.assert_called_once_with(
mock.ANY, fakes.DB_VPN_CONNECTION_1)
self.neutron.delete_ipsec_site_connection.assert_called_once_with(
id_os_connection)
# rollback of deleting subnet vpn connection
self.db_api.reset_mock()
self.neutron.reset_mock()
try:
with common.OnCrashCleaner() as cleaner:
vpn_connection_api._delete_subnet_vpn(
context, self.neutron, cleaner, fakes.DB_SUBNET_2,
copy.deepcopy(fakes.DB_VPN_CONNECTION_1))
raise Exception('fake-exception')
except Exception as ex:
if ex.message != 'fake-exception':
raise
self.db_api.update_item.assert_called_with(mock.ANY,
fakes.DB_VPN_CONNECTION_1)
self.assertFalse(self.neutron.create_ipsec_site_connection.called)
def test_delete_vpn_connection_route(self, reset_vpn_connections):
self.set_mock_db_items(fakes.DB_VPN_CONNECTION_2, fakes.DB_VPN_GATEWAY_2)
resp = self.execute(
"DeleteVpnConnectionRoute",
{"VpnConnectionId": fakes.ID_EC2_VPN_CONNECTION_2, "DestinationCidrBlock": fakes.CIDR_VPN_2_PROPAGATED_1},
)
self.assertEqual({"return": True}, resp)
vpn = tools.update_dict(fakes.DB_VPN_CONNECTION_2, {"cidrs": [fakes.CIDR_VPN_2_PROPAGATED_2]})
self.db_api.update_item.assert_called_once_with(mock.ANY, vpn)
reset_vpn_connections.assert_called_once_with(
mock.ANY, self.neutron, mock.ANY, fakes.DB_VPN_GATEWAY_2, vpn_connections=[vpn]
)
def test_format_vpn_connection(self):
db_vpn_connection_1 = tools.update_dict(fakes.DB_VPN_CONNECTION_1,
{'cidrs': []})
ec2_vpn_connection_1 = tools.patch_dict(fakes.EC2_VPN_CONNECTION_1, {
'routes': [],
'vgwTelemetry': []
}, ('customerGatewayConfiguration', ))
formatted = vpn_connection_api._format_vpn_connection(
db_vpn_connection_1,
{fakes.ID_EC2_CUSTOMER_GATEWAY_1: fakes.DB_CUSTOMER_GATEWAY_1}, {},
{}, {}, {})
formatted.pop('customerGatewayConfiguration')
self.assertThat(ec2_vpn_connection_1, matchers.DictMatches(formatted))
def check(ec2_dhcp_options_id, db_dhcp_options_id, os_dhcp_options):
resp = self.execute('AssociateDhcpOptions', {
'dhcpOptionsId': ec2_dhcp_options_id,
'vpcId': fakes.ID_EC2_VPC_1
})
self.assertEqual(True, resp['return'])
self.db_api.update_item.assert_any_call(
mock.ANY,
tools.update_dict(fakes.DB_VPC_1,
{'dhcp_options_id': db_dhcp_options_id}))
self.assert_any_call(
self.neutron.update_port, fakes.ID_OS_PORT_1,
{'port': self._effective_os_dhcp_options(os_dhcp_options)})
def test_delete_subnet_vpn(self):
context = base.create_context()
cleaner = common.OnCrashCleaner()
# subnet is not connected to the vpn
vpn_connection_api._delete_subnet_vpn(
context, self.neutron, cleaner, fakes.DB_SUBNET_1,
fakes.DB_VPN_CONNECTION_1)
self.assertFalse(self.db_api.update_item.called)
self.assertFalse(self.neutron.delete_ipsec_site_connection.called)
# delete subnet vpn connection
vpn_connection_api._delete_subnet_vpn(
context, self.neutron, cleaner, fakes.DB_SUBNET_2,
copy.deepcopy(fakes.DB_VPN_CONNECTION_1))
self.db_api.update_item.assert_called_once_with(
mock.ANY, tools.update_dict(fakes.DB_VPN_CONNECTION_1,
{'os_ipsec_site_connections': {}}))
self.neutron.delete_ipsec_site_connection.assert_called_once_with(
fakes.ID_OS_IPSEC_SITE_CONNECTION_2)
# delete subnet vpn connection, leave connections of other subnets
self.db_api.reset_mock()
self.neutron.reset_mock()
id_os_connection = fakes.random_os_id()
vpn_connection_1 = copy.deepcopy(fakes.DB_VPN_CONNECTION_1)
(vpn_connection_1['os_ipsec_site_connections']
[fakes.ID_EC2_SUBNET_1]) = id_os_connection
vpn_connection_api._delete_subnet_vpn(
context, self.neutron, cleaner, fakes.DB_SUBNET_1,
vpn_connection_1)
self.db_api.update_item.assert_called_once_with(
mock.ANY, fakes.DB_VPN_CONNECTION_1)
self.neutron.delete_ipsec_site_connection.assert_called_once_with(
id_os_connection)
# rollback of deleting subnet vpn connection
self.db_api.reset_mock()
self.neutron.reset_mock()
try:
with common.OnCrashCleaner() as cleaner:
vpn_connection_api._delete_subnet_vpn(
context, self.neutron, cleaner, fakes.DB_SUBNET_2,
copy.deepcopy(fakes.DB_VPN_CONNECTION_1))
raise Exception('fake-exception')
except Exception as ex:
if str(ex) != 'fake-exception':
raise
self.db_api.update_item.assert_called_with(
mock.ANY, fakes.DB_VPN_CONNECTION_1)
self.assertFalse(self.neutron.create_ipsec_site_connection.called)
def test_create_vpn_connection(self, random_choice, reset_vpn_connections,
describe_vpn_connections):
self.set_mock_db_items(
fakes.DB_VPN_GATEWAY_1, fakes.DB_VPN_GATEWAY_2,
fakes.DB_CUSTOMER_GATEWAY_1, fakes.DB_CUSTOMER_GATEWAY_2,
fakes.DB_VPC_1)
self.neutron.create_ikepolicy.side_effect = (
tools.get_neutron_create('ikepolicy', fakes.ID_OS_IKEPOLICY_1))
self.neutron.create_ipsecpolicy.side_effect = (
tools.get_neutron_create('ipsecpolicy', fakes.ID_OS_IPSECPOLICY_1))
self.db_api.add_item.side_effect = (
tools.get_db_api_add_item(fakes.ID_EC2_VPN_CONNECTION_1))
random_choice.side_effect = iter(fakes.PRE_SHARED_KEY_1)
describe_vpn_connections.return_value = {
'vpnConnectionSet': [fakes.EC2_VPN_CONNECTION_1]}
resp = self.execute(
'CreateVpnConnection',
{'VpnGatewayId': fakes.ID_EC2_VPN_GATEWAY_1,
'CustomerGatewayId': fakes.ID_EC2_CUSTOMER_GATEWAY_1,
'Type': 'ipsec.1',
'Options.StaticRoutesOnly': 'True'})
self.assertThat(
resp,
matchers.DictMatches(
{'vpnConnection': fakes.EC2_VPN_CONNECTION_1}))
self.neutron.create_ikepolicy.assert_called_once_with(
{'ikepolicy': tools.purge_dict(fakes.OS_IKEPOLICY_1, ('id',))})
self.neutron.create_ipsecpolicy.assert_called_once_with(
{'ipsecpolicy': tools.purge_dict(fakes.OS_IPSECPOLICY_1, ('id',))})
random_choice.assert_called_with(vpn_connection_api.SHARED_KEY_CHARS)
new_vpn_connection_1 = tools.update_dict(
fakes.DB_VPN_CONNECTION_1, {'cidrs': [],
'os_ipsec_site_connections': {}})
self.db_api.add_item.assert_called_once_with(
mock.ANY, 'vpn',
tools.purge_dict(new_vpn_connection_1, ('id', 'vpc_id', 'os_id')))
self.neutron.update_ikepolicy.assert_called_once_with(
fakes.ID_OS_IKEPOLICY_1,
{'ikepolicy': {'name': fakes.ID_EC2_VPN_CONNECTION_1}})
self.neutron.update_ipsecpolicy.assert_called_once_with(
fakes.ID_OS_IPSECPOLICY_1,
{'ipsecpolicy': {'name': fakes.ID_EC2_VPN_CONNECTION_1}})
reset_vpn_connections.assert_called_once_with(
mock.ANY, self.neutron, mock.ANY, fakes.DB_VPN_GATEWAY_1,
vpn_connections=[new_vpn_connection_1])
self.assertIsInstance(reset_vpn_connections.call_args[0][2],
common.OnCrashCleaner)
describe_vpn_connections.assert_called_once_with(
mock.ANY, vpn_connection_id=[fakes.ID_EC2_VPN_CONNECTION_1])
def test_detach_network_interface_rollback(self):
network_interface = tools.update_dict(fakes.DB_NETWORK_INTERFACE_2,
{'device_index': 1})
self.set_mock_db_items(network_interface)
self.neutron.show_port.return_value = (
{'port': fakes.OS_PORT_2})
self.neutron.update_port.side_effect = Exception()
self.assert_execution_error(
self.ANY_EXECUTE_ERROR, 'DetachNetworkInterface',
{'AttachmentId': fakes.ID_EC2_NETWORK_INTERFACE_2_ATTACH})
self.db_api.update_item.assert_any_call(
mock.ANY, network_interface)
def check(ec2_dhcp_options_id, db_dhcp_options_id, os_dhcp_options):
resp = self.execute('AssociateDhcpOptions',
{'dhcpOptionsId': ec2_dhcp_options_id,
'vpcId': fakes.ID_EC2_VPC_1})
self.assertEqual(True, resp['return'])
self.db_api.update_item.assert_any_call(
mock.ANY,
tools.update_dict(
fakes.DB_VPC_1,
{'dhcp_options_id': db_dhcp_options_id}))
self.assert_any_call(
self.neutron.update_port,
fakes.ID_OS_PORT_1,
{'port': self._effective_os_dhcp_options(os_dhcp_options)})
def test_stop_gateway_vpn_connections(self, stop_vpn_connection):
context = base.create_context()
cleaner = common.OnCrashCleaner()
vpn_connection_3 = tools.update_dict(fakes.DB_VPN_CONNECTION_1, {
'id': fakes.random_ec2_id('vpn'),
'os_ipsec_site_connections': {}
})
self.set_mock_db_items(fakes.DB_VPN_CONNECTION_1, vpn_connection_3,
fakes.DB_VPN_CONNECTION_2)
vpn_connection_api._stop_gateway_vpn_connections(
context, self.neutron, cleaner, fakes.DB_VPN_GATEWAY_1)
self.assertEqual(2, stop_vpn_connection.call_count)
stop_vpn_connection.assert_any_call(self.neutron,
fakes.DB_VPN_CONNECTION_1)
stop_vpn_connection.assert_any_call(self.neutron, vpn_connection_3)
self.assertEqual(2, self.db_api.update_item.call_count)
self.db_api.update_item.assert_any_call(
mock.ANY,
tools.update_dict(fakes.DB_VPN_CONNECTION_1,
{'os_ipsec_site_connections': {}}))
self.db_api.update_item.assert_any_call(mock.ANY, vpn_connection_3)
self.db_api.reset_mock()
self.neutron.reset_mock()
stop_vpn_connection.reset_mock()
self.set_mock_db_items(fakes.DB_VPN_CONNECTION_1)
try:
with common.OnCrashCleaner() as cleaner:
vpn_connection_api._stop_gateway_vpn_connections(
context, self.neutron, cleaner, fakes.DB_VPN_GATEWAY_1)
raise Exception('fake-exception')
except Exception as ex:
if ex.message != 'fake-exception':
raise
self.db_api.update_item.assert_called_with(mock.ANY,
fakes.DB_VPN_CONNECTION_1)
def test_create_vpn_connection(self, random_choice, reset_vpn_connections, describe_vpn_connections):
self.set_mock_db_items(
fakes.DB_VPN_GATEWAY_1,
fakes.DB_VPN_GATEWAY_2,
fakes.DB_CUSTOMER_GATEWAY_1,
fakes.DB_CUSTOMER_GATEWAY_2,
fakes.DB_VPC_1,
)
self.neutron.create_ikepolicy.side_effect = tools.get_neutron_create("ikepolicy", fakes.ID_OS_IKEPOLICY_1)
self.neutron.create_ipsecpolicy.side_effect = tools.get_neutron_create("ipsecpolicy", fakes.ID_OS_IPSECPOLICY_1)
self.db_api.add_item.side_effect = tools.get_db_api_add_item(fakes.ID_EC2_VPN_CONNECTION_1)
random_choice.side_effect = iter(fakes.PRE_SHARED_KEY_1)
describe_vpn_connections.return_value = {"vpnConnectionSet": [fakes.EC2_VPN_CONNECTION_1]}
resp = self.execute(
"CreateVpnConnection",
{
"VpnGatewayId": fakes.ID_EC2_VPN_GATEWAY_1,
"CustomerGatewayId": fakes.ID_EC2_CUSTOMER_GATEWAY_1,
"Type": "ipsec.1",
"Options.StaticRoutesOnly": "True",
},
)
self.assertThat(resp, matchers.DictMatches({"vpnConnection": fakes.EC2_VPN_CONNECTION_1}))
self.neutron.create_ikepolicy.assert_called_once_with(
{"ikepolicy": tools.purge_dict(fakes.OS_IKEPOLICY_1, ("id",))}
)
self.neutron.create_ipsecpolicy.assert_called_once_with(
{"ipsecpolicy": tools.purge_dict(fakes.OS_IPSECPOLICY_1, ("id",))}
)
random_choice.assert_called_with(vpn_connection_api.SHARED_KEY_CHARS)
new_vpn_connection_1 = tools.update_dict(
fakes.DB_VPN_CONNECTION_1, {"cidrs": [], "os_ipsec_site_connections": {}}
)
self.db_api.add_item.assert_called_once_with(
mock.ANY, "vpn", tools.purge_dict(new_vpn_connection_1, ("id", "vpc_id", "os_id"))
)
self.neutron.update_ikepolicy.assert_called_once_with(
fakes.ID_OS_IKEPOLICY_1, {"ikepolicy": {"name": fakes.ID_EC2_VPN_CONNECTION_1}}
)
self.neutron.update_ipsecpolicy.assert_called_once_with(
fakes.ID_OS_IPSECPOLICY_1, {"ipsecpolicy": {"name": fakes.ID_EC2_VPN_CONNECTION_1}}
)
reset_vpn_connections.assert_called_once_with(
mock.ANY, self.neutron, mock.ANY, fakes.DB_VPN_GATEWAY_1, vpn_connections=[new_vpn_connection_1]
)
self.assertIsInstance(reset_vpn_connections.call_args[0][2], common.OnCrashCleaner)
describe_vpn_connections.assert_called_once_with(mock.ANY, vpn_connection_id=[fakes.ID_EC2_VPN_CONNECTION_1])
def test_modify_network_interface_attribute(self):
self.set_mock_db_items(fakes.DB_NETWORK_INTERFACE_1,
fakes.DB_NETWORK_INTERFACE_2)
self.execute(
'ModifyNetworkInterfaceAttribute',
{'NetworkInterfaceId': fakes.ID_EC2_NETWORK_INTERFACE_1,
'Description.Value': 'New description'})
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.update_dict(fakes.DB_NETWORK_INTERFACE_1,
{'description': 'New description'}))
self.db_api.reset_mock()
self.execute(
'ModifyNetworkInterfaceAttribute',
{'NetworkInterfaceId': fakes.ID_EC2_NETWORK_INTERFACE_2,
'Attachment.AttachmentId': (
fakes.ID_EC2_NETWORK_INTERFACE_2_ATTACH),
'Attachment.DeleteOnTermination': 'True'})
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.update_dict(fakes.DB_NETWORK_INTERFACE_2,
{'delete_on_termination': True}))
def test_delete_route_table_invalid_parameters(self):
self.set_mock_db_items()
self.assert_execution_error(
'InvalidRouteTableID.NotFound', 'DeleteRouteTable',
{'RouteTableId': fakes.ID_EC2_ROUTE_TABLE_1})
self.set_mock_db_items(fakes.DB_ROUTE_TABLE_1, fakes.DB_VPC_1)
self.assert_execution_error(
'DependencyViolation', 'DeleteRouteTable',
{'RouteTableId': fakes.ID_EC2_ROUTE_TABLE_1})
subnet = tools.update_dict(
fakes.DB_SUBNET_2, {'route_table_id': fakes.ID_EC2_ROUTE_TABLE_2})
self.set_mock_db_items(fakes.DB_ROUTE_TABLE_2, fakes.DB_VPC_1, subnet)
self.assert_execution_error(
'DependencyViolation', 'DeleteRouteTable',
{'RouteTableId': fakes.ID_EC2_ROUTE_TABLE_2})
def test_create_network_interface_rollback(self, _add_dhcp_opts_to_port):
self.set_mock_db_items(
tools.update_dict(
fakes.DB_VPC_1,
{'dhcp_options_id': fakes.ID_EC2_DHCP_OPTIONS_1}),
fakes.DB_SUBNET_1, fakes.DB_DHCP_OPTIONS_1)
self.db_api.add_item.return_value = fakes.DB_NETWORK_INTERFACE_1
self.neutron.show_subnet.return_value = {'subnet': fakes.OS_SUBNET_1}
self.neutron.create_port.return_value = {'port': fakes.OS_PORT_1}
_add_dhcp_opts_to_port.side_effect = Exception()
self.assert_execution_error(self.ANY_EXECUTE_ERROR,
'CreateNetworkInterface',
{'SubnetId': fakes.ID_EC2_SUBNET_1})
self.neutron.delete_port.assert_called_once_with(fakes.ID_OS_PORT_1)
self.db_api.delete_item.assert_called_once_with(
mock.ANY, fakes.ID_EC2_NETWORK_INTERFACE_1)
def test_delete_vpn_connection_route(self, reset_vpn_connections):
self.set_mock_db_items(fakes.DB_VPN_CONNECTION_2,
fakes.DB_VPN_GATEWAY_2)
resp = self.execute(
'DeleteVpnConnectionRoute', {
'VpnConnectionId': fakes.ID_EC2_VPN_CONNECTION_2,
'DestinationCidrBlock': fakes.CIDR_VPN_2_PROPAGATED_1
})
self.assertEqual({'return': True}, resp)
vpn = tools.update_dict(fakes.DB_VPN_CONNECTION_2,
{'cidrs': [fakes.CIDR_VPN_2_PROPAGATED_2]})
self.db_api.update_item.assert_called_once_with(mock.ANY, vpn)
reset_vpn_connections.assert_called_once_with(mock.ANY,
self.neutron,
mock.ANY,
fakes.DB_VPN_GATEWAY_2,
vpn_connections=[vpn])
def do_check():
resp = self.execute(
'DetachVpnGateway',
{'VpcId': fakes.ID_EC2_VPC_1,
'VpnGatewayId': fakes.ID_EC2_VPN_GATEWAY_1})
self.assertEqual({'return': True}, resp)
self.assertEqual(3, self.db_api.update_item.call_count)
self.db_api.update_item.assert_has_calls(
[mock.call(mock.ANY, self.DB_VPN_GATEWAY_1_DETACHED),
mock.call(mock.ANY,
tools.update_dict(
fakes.DB_VPN_CONNECTION_1,
{'os_ipsec_site_connections': {}})),
mock.call(mock.ANY, self.DB_SUBNET_1_NO_VPN)])
self.neutron.delete_vpnservice.assert_called_once_with(
fakes.ID_OS_VPNSERVICE_1)
self.neutron.delete_ipsec_site_connection.assert_called_once_with(
fakes.ID_OS_IPSEC_SITE_CONNECTION_2)
def test_replace_route_table_association_main(self, routes_updater):
self.set_mock_db_items(fakes.DB_ROUTE_TABLE_1, fakes.DB_ROUTE_TABLE_2,
fakes.DB_VPC_1)
resp = self.execute(
'ReplaceRouteTableAssociation', {
'AssociationId': fakes.ID_EC2_ROUTE_TABLE_ASSOCIATION_1,
'RouteTableId': fakes.ID_EC2_ROUTE_TABLE_2
})
self.assertEqual(fakes.ID_EC2_ROUTE_TABLE_ASSOCIATION_1,
resp['newAssociationId'])
vpc = tools.update_dict(fakes.DB_VPC_1,
{'route_table_id': fakes.ID_EC2_ROUTE_TABLE_2})
self.db_api.update_item.assert_called_once_with(mock.ANY, vpc)
routes_updater.assert_called_once_with(mock.ANY,
fakes.DB_ROUTE_TABLE_2,
mock.ANY,
fakes.DB_ROUTE_TABLE_1,
is_main=True)
def test_create_network_interface_rollback(self, _add_dhcp_opts_to_port):
self.set_mock_db_items(
tools.update_dict(
fakes.DB_VPC_1,
{'dhcp_options_id': fakes.ID_EC2_DHCP_OPTIONS_1}),
fakes.DB_SUBNET_1, fakes.DB_DHCP_OPTIONS_1)
self.db_api.add_item.return_value = fakes.DB_NETWORK_INTERFACE_1
self.neutron.show_subnet.return_value = {'subnet': fakes.OS_SUBNET_1}
self.neutron.create_port.return_value = {'port': fakes.OS_PORT_1}
_add_dhcp_opts_to_port.side_effect = Exception()
self.assert_execution_error(self.ANY_EXECUTE_ERROR,
'CreateNetworkInterface',
{'SubnetId': fakes.ID_EC2_SUBNET_1})
self.neutron.delete_port.assert_called_once_with(fakes.ID_OS_PORT_1)
self.db_api.delete_item.assert_called_once_with(
mock.ANY, fakes.ID_EC2_NETWORK_INTERFACE_1)
def do_check(params, fixed_ip):
resp = self.execute('AssociateAddress', params)
self.assertEqual(True, resp['return'])
self.assertEqual(fakes.ID_EC2_ASSOCIATION_1, resp['associationId'])
self.neutron.update_floatingip.assert_called_once_with(
fakes.ID_OS_FLOATING_IP_1,
{'floatingip': {'port_id': fakes.ID_OS_PORT_2,
'fixed_ip_address': fixed_ip}})
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.update_dict(
fakes.DB_ADDRESS_1,
{'network_interface_id':
fakes.ID_EC2_NETWORK_INTERFACE_2,
'private_ip_address': fixed_ip}))
self.neutron.update_floatingip.reset_mock()
self.db_api.update_item.reset_mock()
def test_replace_route_table_association(self, routes_updater):
self.set_mock_db_items(fakes.DB_ROUTE_TABLE_2, fakes.DB_ROUTE_TABLE_3,
fakes.DB_SUBNET_2)
resp = self.execute(
'ReplaceRouteTableAssociation', {
'AssociationId': fakes.ID_EC2_ROUTE_TABLE_ASSOCIATION_3,
'RouteTableId': fakes.ID_EC2_ROUTE_TABLE_2
})
self.assertEqual(fakes.ID_EC2_ROUTE_TABLE_ASSOCIATION_2,
resp['newAssociationId'])
subnet = tools.update_dict(
fakes.DB_SUBNET_2, {'route_table_id': fakes.ID_EC2_ROUTE_TABLE_2})
self.db_api.update_item.assert_called_once_with(mock.ANY, subnet)
routes_updater.assert_called_once_with(
mock.ANY,
subnet,
fakes.DB_ROUTE_TABLE_2,
cleaner=mock.ANY,
rollback_route_table_object=fakes.DB_ROUTE_TABLE_3)
def test_associate_route_table(self, routes_updater):
self.set_mock_db_items(fakes.DB_VPC_1, fakes.DB_ROUTE_TABLE_1,
fakes.DB_SUBNET_1)
resp = self.execute(
'AssociateRouteTable', {
'RouteTableId': fakes.ID_EC2_ROUTE_TABLE_1,
'SubnetId': fakes.ID_EC2_SUBNET_1
})
self.assertEqual(fakes.ID_EC2_SUBNET_1.replace('subnet', 'rtbassoc'),
resp['associationId'])
subnet = tools.update_dict(
fakes.DB_SUBNET_1, {'route_table_id': fakes.ID_EC2_ROUTE_TABLE_1})
self.db_api.update_item.assert_called_once_with(mock.ANY, subnet)
routes_updater.assert_called_once_with(
mock.ANY,
subnet,
fakes.DB_ROUTE_TABLE_1,
cleaner=mock.ANY,
rollback_route_table_object=fakes.DB_ROUTE_TABLE_1)
def do_check(params, fixed_ip):
resp = self.execute('AssociateAddress', params)
self.assertEqual(True, resp['return'])
self.assertEqual(fakes.ID_EC2_ASSOCIATION_1, resp['associationId'])
self.neutron.update_floatingip.assert_called_once_with(
fakes.ID_OS_FLOATING_IP_1,
{'floatingip': {'port_id': fakes.ID_OS_PORT_2,
'fixed_ip_address': fixed_ip}})
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.update_dict(
fakes.DB_ADDRESS_1,
{'network_interface_id':
fakes.ID_EC2_NETWORK_INTERFACE_2,
'private_ip_address': fixed_ip}))
self.neutron.update_floatingip.reset_mock()
self.db_api.update_item.reset_mock()
def test_attach_network_interface(self):
self.set_mock_db_items(fakes.DB_NETWORK_INTERFACE_1,
fakes.DB_INSTANCE_1)
self.neutron.show_port.return_value = (
{'port': fakes.OS_PORT_1})
self.isotime.return_value = fakes.TIME_ATTACH_NETWORK_INTERFACE
self.execute(
'AttachNetworkInterface',
{'NetworkInterfaceId': fakes.ID_EC2_NETWORK_INTERFACE_1,
'InstanceId': fakes.ID_EC2_INSTANCE_1,
'DeviceIndex': '1'})
self.nova.servers.interface_attach.assert_called_once_with(
fakes.ID_OS_INSTANCE_1, fakes.ID_OS_PORT_1, None, None)
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.update_dict(
fakes.DB_NETWORK_INTERFACE_1,
{'device_index': 1,
'instance_id': fakes.ID_EC2_INSTANCE_1,
'delete_on_termination': False,
'attach_time': fakes.TIME_ATTACH_NETWORK_INTERFACE}))
def test_associate_route_table_invalid_parameters(self):
def do_check(params, error_code):
self.assert_execution_error(error_code, 'AssociateRouteTable',
params)
self.set_mock_db_items()
do_check(
{
'RouteTableId': fakes.ID_EC2_ROUTE_TABLE_1,
'SubnetId': fakes.ID_EC2_SUBNET_1
}, 'InvalidRouteTableID.NotFound')
self.set_mock_db_items(fakes.DB_ROUTE_TABLE_1)
do_check(
{
'RouteTableId': fakes.ID_EC2_ROUTE_TABLE_1,
'SubnetId': fakes.ID_EC2_SUBNET_1
}, 'InvalidSubnetID.NotFound')
id_ec2_subnet_vpc_2 = fakes.random_ec2_id('subnet')
db_subnet_vpc_2 = {
'id': id_ec2_subnet_vpc_2,
'os_id': fakes.random_os_id(),
'vpc_id': fakes.ID_EC2_VPC_2
}
self.set_mock_db_items(fakes.DB_ROUTE_TABLE_1, db_subnet_vpc_2)
do_check(
{
'RouteTableId': fakes.ID_EC2_ROUTE_TABLE_1,
'SubnetId': id_ec2_subnet_vpc_2
}, 'InvalidParameterValue')
subnet_2 = tools.update_dict(
fakes.DB_SUBNET_2, {'route_table_id': fakes.ID_EC2_ROUTE_TABLE_2})
self.set_mock_db_items(fakes.DB_ROUTE_TABLE_1, subnet_2)
do_check(
{
'RouteTableId': fakes.ID_EC2_ROUTE_TABLE_1,
'SubnetId': fakes.ID_EC2_SUBNET_2
}, 'Resource.AlreadyAssociated')
def test_detach_network_interface(self):
network_interface = tools.update_dict(fakes.DB_NETWORK_INTERFACE_2,
{'device_index': 1})
self.set_mock_db_items(network_interface)
self.neutron.show_port.return_value = (
{'port': fakes.OS_PORT_2})
self.execute(
'DetachNetworkInterface',
{'AttachmentId': ec2utils.change_ec2_id_kind(
fakes.ID_EC2_NETWORK_INTERFACE_2, 'eni-attach')})
self.neutron.update_port.assert_called_once_with(
fakes.ID_OS_PORT_2,
{'port': {'device_id': '',
'device_owner': ''}}
)
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.purge_dict(fakes.DB_NETWORK_INTERFACE_2,
{'device_index',
'instance_id',
'delete_on_termination',
'attach_time'}))
def test_attach_network_interface(self):
self.set_mock_db_items(fakes.DB_NETWORK_INTERFACE_1,
fakes.DB_INSTANCE_1)
self.neutron.show_port.return_value = ({'port': fakes.OS_PORT_1})
self.isotime.return_value = fakes.TIME_ATTACH_NETWORK_INTERFACE
self.execute(
'AttachNetworkInterface', {
'NetworkInterfaceId': fakes.ID_EC2_NETWORK_INTERFACE_1,
'InstanceId': fakes.ID_EC2_INSTANCE_1,
'DeviceIndex': '1'
})
self.nova.servers.interface_attach.assert_called_once_with(
fakes.ID_OS_INSTANCE_1, fakes.ID_OS_PORT_1, None, None)
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.update_dict(
fakes.DB_NETWORK_INTERFACE_1, {
'device_index': 1,
'instance_id': fakes.ID_EC2_INSTANCE_1,
'delete_on_termination': False,
'attach_time': fakes.TIME_ATTACH_NETWORK_INTERFACE
}))
def test_attach_igw(self):
self.configure(external_network=fakes.NAME_OS_PUBLIC_NETWORK)
self.set_mock_db_items(fakes.DB_IGW_1, fakes.DB_IGW_2, fakes.DB_VPC_2,
fakes.DB_VPN_GATEWAY_1, fakes.DB_VPN_GATEWAY_2)
self.neutron.list_networks.return_value = ({
'networks': [{
'id': fakes.ID_OS_PUBLIC_NETWORK
}]
})
def do_check():
resp = self.execute(
'AttachInternetGateway', {
'VpcId': fakes.ID_EC2_VPC_2,
'InternetGatewayId': fakes.ID_EC2_IGW_2
})
self.assertEqual(True, resp['return'])
self.db_api.update_item.assert_called_once_with(
mock.ANY, self.DB_IGW_2_ATTACHED)
do_check()
self.neutron.add_gateway_router.assert_called_once_with(
fakes.ID_OS_ROUTER_2, {'network_id': fakes.ID_OS_PUBLIC_NETWORK})
self.neutron.list_networks.assert_called_once_with(
**{
'router:external': True,
'name': fakes.NAME_OS_PUBLIC_NETWORK
})
# VPN gateway is already attached
self.db_api.reset_mock()
self.neutron.reset_mock()
vgw_2 = tools.update_dict(fakes.DB_VPN_GATEWAY_2,
{'vpc_id': fakes.ID_EC2_VPC_2})
self.add_mock_db_items(vgw_2)
do_check()
self.assertFalse(self.neutron.add_gateway_router.called)
def test_detach_vpn_gateway(self):
self.set_mock_db_items(
fakes.DB_VPN_GATEWAY_1, fakes.DB_VPC_1, fakes.DB_VPN_CONNECTION_1,
fakes.DB_SUBNET_1,
tools.update_dict(fakes.DB_SUBNET_2,
{'vpc_id': fakes.ID_EC2_VPC_2}))
def do_check():
resp = self.execute(
'DetachVpnGateway',
{'VpcId': fakes.ID_EC2_VPC_1,
'VpnGatewayId': fakes.ID_EC2_VPN_GATEWAY_1})
self.assertEqual({'return': True}, resp)
self.assertEqual(3, self.db_api.update_item.call_count)
self.db_api.update_item.assert_has_calls(
[mock.call(mock.ANY, self.DB_VPN_GATEWAY_1_DETACHED),
mock.call(mock.ANY,
tools.update_dict(
fakes.DB_VPN_CONNECTION_1,
{'os_ipsec_site_connections': {}})),
mock.call(mock.ANY, self.DB_SUBNET_1_NO_VPN)])
self.neutron.delete_vpnservice.assert_called_once_with(
fakes.ID_OS_VPNSERVICE_1)
self.neutron.delete_ipsec_site_connection.assert_called_once_with(
fakes.ID_OS_IPSEC_SITE_CONNECTION_2)
do_check()
self.neutron.remove_gateway_router.assert_called_once_with(
fakes.ID_OS_ROUTER_1)
# Internet gateway is still attached
self.db_api.reset_mock()
self.neutron.reset_mock()
self.add_mock_db_items(fakes.DB_IGW_1)
do_check()
self.neutron.remove_gateway_router.assert_not_called()
def test_detach_network_interface(self):
network_interface = tools.update_dict(fakes.DB_NETWORK_INTERFACE_2,
{'device_index': 1})
self.set_mock_db_items(network_interface)
self.neutron.show_port.return_value = ({'port': fakes.OS_PORT_2})
self.execute(
'DetachNetworkInterface', {
'AttachmentId':
ec2utils.change_ec2_id_kind(fakes.ID_EC2_NETWORK_INTERFACE_2,
'eni-attach')
})
self.neutron.update_port.assert_called_once_with(
fakes.ID_OS_PORT_2,
{'port': {
'device_id': '',
'device_owner': ''
}})
self.db_api.update_item.assert_called_once_with(
mock.ANY,
tools.purge_dict(
fakes.DB_NETWORK_INTERFACE_2, {
'device_index', 'instance_id', 'delete_on_termination',
'attach_time'
}))
def test_get_route_table_vpn_cidrs(self):
route_table_1 = copy.deepcopy(fakes.DB_ROUTE_TABLE_1)
vpn_connection_1 = tools.update_dict(
fakes.DB_VPN_CONNECTION_1, {'cidrs': []})
vpn_connection_2 = tools.update_dict(
vpn_connection_1, {'id': fakes.ID_EC2_VPN_CONNECTION_2})
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1, []),
matchers.DictMatches({}))
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1,
[vpn_connection_1, vpn_connection_2]),
matchers.DictMatches({}))
route_table_1['propagating_gateways'] = [fakes.ID_EC2_VPN_GATEWAY_1,
fakes.ID_EC2_VPN_GATEWAY_2]
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1,
[vpn_connection_1, vpn_connection_2]),
matchers.DictMatches({}))
vpn_connection_1['cidrs'] = ['cidr_1']
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1,
[vpn_connection_1, vpn_connection_2]),
matchers.DictMatches({fakes.ID_EC2_VPN_CONNECTION_1: ['cidr_1']}))
vpn_connection_2['cidrs'] = ['cidr_1', 'cidr_2']
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1,
[vpn_connection_1, vpn_connection_2]),
matchers.DictMatches(
{fakes.ID_EC2_VPN_CONNECTION_1: ['cidr_1'],
fakes.ID_EC2_VPN_CONNECTION_2: ['cidr_1', 'cidr_2']},
orderless_lists=True))
route_table_1['routes'] = [
{'destination_cidr_block': 'fake_1',
'network_interface_id': fakes.ID_EC2_NETWORK_INTERFACE_1},
{'destination_cidr_block': 'fake_2',
'gateway_id': None},
{'destination_cidr_block': 'fake_3',
'gateway_id': fakes.ID_EC2_IGW_1},
{'destination_cidr_block': 'cidr_3',
'gateway_id': fakes.ID_EC2_VPN_GATEWAY_1},
{'destination_cidr_block': 'cidr_4',
'gateway_id': fakes.ID_EC2_VPN_GATEWAY_1},
{'destination_cidr_block': 'fake_4',
'gateway_id': fakes.ID_EC2_VPN_GATEWAY_2}]
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1,
[vpn_connection_1, vpn_connection_2]),
matchers.DictMatches(
{fakes.ID_EC2_VPN_CONNECTION_1: ['cidr_1', 'cidr_3', 'cidr_4'],
fakes.ID_EC2_VPN_CONNECTION_2: ['cidr_1', 'cidr_2',
'cidr_3', 'cidr_4']},
orderless_lists=True))
route_table_1['propagating_gateways'] = [fakes.ID_EC2_VPN_GATEWAY_2]
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1,
[vpn_connection_1, vpn_connection_2]),
matchers.DictMatches(
{fakes.ID_EC2_VPN_CONNECTION_1: ['cidr_3', 'cidr_4'],
fakes.ID_EC2_VPN_CONNECTION_2: ['cidr_3', 'cidr_4']},
orderless_lists=True))
def test_detach_vpn_gateway(self, delete_vpnservice,
stop_gateway_vpn_connections):
delete_vpnservice_calls = []
delete_vpnservice.side_effect = (
tools.deepcopy_call_args_saver(delete_vpnservice_calls))
mock_manager = mock.Mock()
mock_manager.attach_mock(delete_vpnservice, 'delete_vpnservice')
mock_manager.attach_mock(stop_gateway_vpn_connections,
'stop_gateway_vpn_connections')
self.set_mock_db_items(
fakes.DB_VPN_GATEWAY_1, fakes.DB_VPC_1, fakes.DB_VPN_CONNECTION_1,
fakes.DB_SUBNET_1,
tools.update_dict(fakes.DB_SUBNET_2,
{'vpc_id': fakes.ID_EC2_VPC_2}))
def do_check():
resp = self.execute(
'DetachVpnGateway',
{'VpcId': fakes.ID_EC2_VPC_1,
'VpnGatewayId': fakes.ID_EC2_VPN_GATEWAY_1})
self.assertEqual({'return': True}, resp)
self.assertEqual(3, self.db_api.update_item.call_count)
self.db_api.update_item.assert_has_calls(
[mock.call(mock.ANY, self.DB_VPN_GATEWAY_1_DETACHED),
mock.call(mock.ANY,
tools.update_dict(
fakes.DB_VPN_CONNECTION_1,
{'os_ipsec_site_connections': {}})),
mock.call(mock.ANY, self.DB_SUBNET_1_NO_VPN)])
self.neutron.delete_vpnservice.assert_called_once_with(
fakes.ID_OS_VPNSERVICE_1)
self.assertEqual(1, len(delete_vpnservice_calls))
self.assertEqual(
mock.call(mock.ANY, self.neutron, mock.ANY, fakes.DB_SUBNET_1),
delete_vpnservice_calls[0])
self.assertIsInstance(delete_vpnservice_calls[0][1][2],
common.OnCrashCleaner)
stop_gateway_vpn_connections.assert_called_once_with(
mock.ANY, self.neutron, mock.ANY,
self.DB_VPN_GATEWAY_1_DETACHED)
self.assertIsInstance(stop_gateway_vpn_connections.call_args[0][2],
common.OnCrashCleaner)
self.neutron.delete_ipsec_site_connection.assert_called_once_with(
fakes.ID_OS_IPSEC_SITE_CONNECTION_2)
mock_manager.assert_has_calls([
mock.call.stop_gateway_vpn_connections(
*(mock.ANY for _x in range(4))),
mock.call.delete_vpnservice(
*(mock.ANY for _x in range(4)))])
do_check()
self.neutron.remove_gateway_router.assert_called_once_with(
fakes.ID_OS_ROUTER_1)
# Internet gateway is still attached
self.db_api.reset_mock()
self.neutron.reset_mock()
del delete_vpnservice_calls[:]
stop_gateway_vpn_connections.reset_mock()
mock_manager.reset_mock()
self.add_mock_db_items(fakes.DB_IGW_1)
do_check()
self.assertFalse(self.neutron.remove_gateway_router.called)
def test_attach_vpn_gateway(self, create_vpnservice,
reset_vpn_connections):
create_vpnservice_calls = []
create_vpnservice.side_effect = (
tools.deepcopy_call_args_saver(create_vpnservice_calls))
mock_manager = mock.Mock()
mock_manager.attach_mock(create_vpnservice, 'create_vpnservice')
mock_manager.attach_mock(reset_vpn_connections,
'reset_vpn_connections')
self.configure(external_network=fakes.NAME_OS_PUBLIC_NETWORK)
subnet_2 = tools.patch_dict(fakes.DB_SUBNET_2,
{'vpc_id': fakes.ID_EC2_VPC_2},
('os_vpnservice_id',))
self.set_mock_db_items(
fakes.DB_VPN_GATEWAY_1, fakes.DB_VPN_GATEWAY_2,
fakes.DB_VPC_2, fakes.DB_IGW_1, fakes.DB_IGW_2,
fakes.DB_SUBNET_1, subnet_2)
subnet_2_updated = tools.update_dict(
subnet_2, {'os_vpnservice_id': fakes.ID_OS_VPNSERVICE_2})
os_vpnservice_2 = tools.patch_dict(fakes.OS_VPNSERVICE_2,
{'router_id': fakes.ID_OS_ROUTER_2},
('id',))
self.neutron.list_networks.return_value = (
{'networks': [{'id': fakes.ID_OS_PUBLIC_NETWORK}]})
self.neutron.create_vpnservice.side_effect = tools.get_neutron_create(
'vpnservice', fakes.ID_OS_VPNSERVICE_2)
def do_check():
resp = self.execute('AttachVpnGateway',
{'VpcId': fakes.ID_EC2_VPC_2,
'VpnGatewayId': fakes.ID_EC2_VPN_GATEWAY_2})
self.assertEqual({'attachment': {'state': 'attached',
'vpcId': fakes.ID_EC2_VPC_2}},
resp)
self.assertEqual(2, self.db_api.update_item.call_count)
self.db_api.update_item.assert_has_calls(
[mock.call(mock.ANY, self.DB_VPN_GATEWAY_2_ATTACHED),
mock.call(mock.ANY, subnet_2_updated)])
self.neutron.create_vpnservice.assert_called_once_with(
{'vpnservice': os_vpnservice_2})
self.assertEqual(1, len(create_vpnservice_calls))
self.assertEqual(
mock.call(mock.ANY, self.neutron, mock.ANY, subnet_2,
fakes.DB_VPC_2),
create_vpnservice_calls[0])
self.assertIsInstance(create_vpnservice_calls[0][1][2],
common.OnCrashCleaner)
reset_vpn_connections.assert_called_once_with(
mock.ANY, self.neutron, mock.ANY,
self.DB_VPN_GATEWAY_2_ATTACHED, subnets=[subnet_2_updated])
self.assertIsInstance(reset_vpn_connections.call_args[0][2],
common.OnCrashCleaner)
mock_manager.assert_has_calls([
mock.call.create_vpnservice(
*(mock.ANY for _x in range(5))),
mock.call.reset_vpn_connections(
subnets=mock.ANY, *(mock.ANY for _x in range(4)))])
do_check()
self.neutron.add_gateway_router.assert_called_once_with(
fakes.ID_OS_ROUTER_2,
{'network_id': fakes.ID_OS_PUBLIC_NETWORK})
self.neutron.list_networks.assert_called_once_with(
**{'router:external': True,
'name': fakes.NAME_OS_PUBLIC_NETWORK})
# Internet gateway is already attached
self.db_api.reset_mock()
self.neutron.reset_mock()
del create_vpnservice_calls[:]
reset_vpn_connections.reset_mock()
mock_manager.reset_mock()
igw_2 = tools.update_dict(fakes.DB_IGW_2,
{'vpc_id': fakes.ID_EC2_VPC_2})
self.add_mock_db_items(igw_2)
do_check()
self.assertFalse(self.neutron.add_gateway_router.called)
def test_describe_vpn_connections(self):
self.set_mock_db_items(
fakes.DB_VPN_CONNECTION_1, fakes.DB_VPN_CONNECTION_2,
fakes.DB_CUSTOMER_GATEWAY_1, fakes.DB_CUSTOMER_GATEWAY_2,
fakes.DB_VPN_GATEWAY_1, fakes.DB_VPN_GATEWAY_2,
fakes.DB_VPC_1, fakes.DB_VPC_2)
self.neutron.list_ikepolicies.return_value = {
'ikepolicies': [fakes.OS_IKEPOLICY_1, fakes.OS_IKEPOLICY_2]}
self.neutron.list_ipsecpolicies.return_value = {
'ipsecpolicies': [fakes.OS_IPSECPOLICY_1, fakes.OS_IPSECPOLICY_2]}
self.neutron.list_ipsec_site_connections.return_value = {
'ipsec_site_connections': []}
self.neutron.list_routers.return_value = {
'routers': [fakes.OS_ROUTER_1, fakes.OS_ROUTER_2]}
resp = self.execute('DescribeVpnConnections', {})
vpns = [tools.update_dict(
vpn, {'customerGatewayConfiguration': 'DONTCARE'})
for vpn in (fakes.EC2_VPN_CONNECTION_1,
fakes.EC2_VPN_CONNECTION_2)]
self.assertThat(
resp,
matchers.DictMatches(
{'vpnConnectionSet': vpns},
orderless_lists=True))
for vpn in (fakes.EC2_VPN_CONNECTION_1, fakes.EC2_VPN_CONNECTION_2):
config = next(v['customerGatewayConfiguration']
for v in resp['vpnConnectionSet']
if v['vpnConnectionId'] == vpn['vpnConnectionId'])
self.assertThat(
config.encode(),
matchers.XMLMatches(
vpn['customerGatewayConfiguration'].encode(),
orderless_sequence=True))
self.assertTrue(config.startswith(
'<?xml version=\'1.0\' encoding=\'UTF-8\'?>'))
self.neutron.list_ikepolicies.assert_called_once_with(
tenant_id=fakes.ID_OS_PROJECT)
self.neutron.list_ipsecpolicies.assert_called_once_with(
tenant_id=fakes.ID_OS_PROJECT)
self.neutron.list_ipsec_site_connections.assert_called_once_with(
tenant_id=fakes.ID_OS_PROJECT)
self.neutron.list_routers.assert_called_once_with(
tenant_id=fakes.ID_OS_PROJECT)
resp = self.execute(
'DescribeVpnConnections',
{'VpnConnectionId.1': fakes.ID_EC2_VPN_CONNECTION_1})
self.assertThat(
resp,
matchers.DictMatches(
{'vpnConnectionSet': [vpns[0]]},
orderless_lists=True))
self.check_filtering(
'DescribeVpnConnections', 'vpnConnectionSet',
[('customer-gateway-configuration',
'*' + fakes.PRE_SHARED_KEY_1 + '*'),
('customer-gateway-id', fakes.ID_EC2_CUSTOMER_GATEWAY_1),
('state', 'available'),
('option.static-routes-only', True),
('route.destination-cidr-block', fakes.CIDR_VPN_2_PROPAGATED_1),
('type', 'ipsec.1'),
('vpn-connection-id', fakes.ID_EC2_VPN_CONNECTION_1),
('vpn-gateway-id', fakes.ID_EC2_VPN_GATEWAY_1)])
self.check_tag_support(
'DescribeVpnConnections', 'vpnConnectionSet',
fakes.ID_EC2_VPN_CONNECTION_1, 'vpnConnectionId')
def test_get_route_table_vpn_cidrs(self):
route_table_1 = copy.deepcopy(fakes.DB_ROUTE_TABLE_1)
vpn_connection_1 = tools.update_dict(fakes.DB_VPN_CONNECTION_1, {"cidrs": []})
vpn_connection_2 = tools.update_dict(vpn_connection_1, {"id": fakes.ID_EC2_VPN_CONNECTION_2})
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(route_table_1, fakes.DB_VPN_GATEWAY_1, []),
matchers.DictMatches({}),
)
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1, [vpn_connection_1, vpn_connection_2]
),
matchers.DictMatches({}),
)
route_table_1["propagating_gateways"] = [fakes.ID_EC2_VPN_GATEWAY_1, fakes.ID_EC2_VPN_GATEWAY_2]
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1, [vpn_connection_1, vpn_connection_2]
),
matchers.DictMatches({}),
)
vpn_connection_1["cidrs"] = ["cidr_1"]
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1, [vpn_connection_1, vpn_connection_2]
),
matchers.DictMatches({fakes.ID_EC2_VPN_CONNECTION_1: ["cidr_1"]}),
)
vpn_connection_2["cidrs"] = ["cidr_1", "cidr_2"]
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1, [vpn_connection_1, vpn_connection_2]
),
matchers.DictMatches(
{fakes.ID_EC2_VPN_CONNECTION_1: ["cidr_1"], fakes.ID_EC2_VPN_CONNECTION_2: ["cidr_1", "cidr_2"]},
orderless_lists=True,
),
)
route_table_1["routes"] = [
{"destination_cidr_block": "fake_1", "network_interface_id": fakes.ID_EC2_NETWORK_INTERFACE_1},
{"destination_cidr_block": "fake_2", "gateway_id": None},
{"destination_cidr_block": "fake_3", "gateway_id": fakes.ID_EC2_IGW_1},
{"destination_cidr_block": "cidr_3", "gateway_id": fakes.ID_EC2_VPN_GATEWAY_1},
{"destination_cidr_block": "cidr_4", "gateway_id": fakes.ID_EC2_VPN_GATEWAY_1},
{"destination_cidr_block": "fake_4", "gateway_id": fakes.ID_EC2_VPN_GATEWAY_2},
]
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1, [vpn_connection_1, vpn_connection_2]
),
matchers.DictMatches(
{
fakes.ID_EC2_VPN_CONNECTION_1: ["cidr_1", "cidr_3", "cidr_4"],
fakes.ID_EC2_VPN_CONNECTION_2: ["cidr_1", "cidr_2", "cidr_3", "cidr_4"],
},
orderless_lists=True,
),
)
route_table_1["propagating_gateways"] = [fakes.ID_EC2_VPN_GATEWAY_2]
self.assertThat(
vpn_connection_api._get_route_table_vpn_cidrs(
route_table_1, fakes.DB_VPN_GATEWAY_1, [vpn_connection_1, vpn_connection_2]
),
matchers.DictMatches(
{
fakes.ID_EC2_VPN_CONNECTION_1: ["cidr_3", "cidr_4"],
fakes.ID_EC2_VPN_CONNECTION_2: ["cidr_3", "cidr_4"],
},
orderless_lists=True,
),
)
def test_describe_images_being_created(self):
db_api = self.mock_db()
glance = self.mock_glance()
context = base.create_context()
image_id = fakes.random_ec2_id('ami')
image = {'id': image_id,
'os_id': None,
'is_public': False,
'description': 'fake desc'}
db_api.set_mock_items(image)
db_api.get_public_items.return_value = []
# describe cases when no glance image exists
glance.images.list.return_value = []
expected = {'imagesSet': [{'imageId': image_id,
'description': 'fake desc',
'imageOwnerId': fakes.ID_OS_PROJECT,
'imageState': 'pending',
'imageType': 'machine',
'isPublic': False}]}
# describe all images
result = image_api.describe_images(context)
self.assertEqual(expected, result)
# describe the image
result = image_api.describe_images(context, image_id=[image_id])
self.assertEqual(expected, result)
# describe with filter
result = image_api.describe_images(
context, filter=[{'name': 'name', 'value': 'noname'}])
self.assertEqual({'imagesSet': []}, result)
# describe failed image
image['state'] = 'failed'
expected['imagesSet'][0]['imageState'] = 'failed'
result = image_api.describe_images(base.create_context())
self.assertEqual(expected, result)
# describe cases when glance image exists, db item is yet not updated
del image['state']
os_image_id = fakes.random_os_id()
os_image = {'id': os_image_id,
'owner': fakes.ID_OS_PROJECT,
'status': 'active',
'visibility': 'private',
'ec2_id': image_id}
glance.images.list.return_value = [fakes.OSImage(os_image)]
expected['imagesSet'] = [{
'architecture': None,
'creationDate': None,
'description': 'fake desc',
'imageId': image_id,
'imageLocation': 'None (None)',
'imageOwnerId': fakes.ID_OS_PROJECT,
'imageState': 'available',
'imageType': 'machine',
'isPublic': False,
'name': None,
'rootDeviceType': 'instance-store'}]
# describe all images
result = image_api.describe_images(context)
self.assertEqual(expected, result)
db_api.update_item.assert_called_once_with(
context, tools.update_dict(image, {'os_id': os_image_id}))
# describe the image
db_api.reset_mock()
result = image_api.describe_images(context, image_id=[image_id])
self.assertEqual(expected, result)
db_api.update_item.assert_called_once_with(
context, tools.update_dict(image, {'os_id': os_image_id}))
def test_describe_images_being_created(self):
db_api = self.mock_db()
glance = self.mock_glance()
context = base.create_context()
image_id = fakes.random_ec2_id('ami')
image = {
'id': image_id,
'os_id': None,
'is_public': False,
'description': 'fake desc'
}
db_api.set_mock_items(image)
db_api.get_public_items.return_value = []
# describe cases when no glance image exists
glance.images.list.return_value = []
expected = {
'imagesSet': [{
'imageId': image_id,
'description': 'fake desc',
'imageOwnerId': fakes.ID_OS_PROJECT,
'imageState': 'pending',
'imageType': 'machine',
'isPublic': False
}]
}
# describe all images
result = image_api.describe_images(context)
self.assertEqual(expected, result)
# describe the image
result = image_api.describe_images(context, image_id=[image_id])
self.assertEqual(expected, result)
# describe failed image
image['state'] = 'failed'
expected['imagesSet'][0]['imageState'] = 'failed'
result = image_api.describe_images(base.create_context())
self.assertEqual(expected, result)
# describe cases when glance image exists, db item is yet not updated
del image['state']
os_image_id = fakes.random_os_id()
os_image = {
'id': os_image_id,
'owner': fakes.ID_OS_PROJECT,
'status': 'active',
'is_public': False,
'properties': {
'ec2_id': image_id
}
}
glance.images.list.return_value = [fakes.OSImage(os_image)]
expected['imagesSet'] = [{
'architecture': None,
'creationDate': None,
'description': 'fake desc',
'imageId': image_id,
'imageLocation': 'None (None)',
'imageOwnerId': fakes.ID_OS_PROJECT,
'imageState': 'available',
'imageType': 'machine',
'isPublic': False,
'name': None,
'rootDeviceType': 'instance-store'
}]
# describe all images
result = image_api.describe_images(context)
self.assertEqual(expected, result)
db_api.update_item.assert_called_once_with(
context, tools.update_dict(image, {'os_id': os_image_id}))
# describe the image
db_api.reset_mock()
result = image_api.describe_images(context, image_id=[image_id])
self.assertEqual(expected, result)
db_api.update_item.assert_called_once_with(
context, tools.update_dict(image, {'os_id': os_image_id}))
'fakeInt': 1234,
'fakeStr': 'fake',
'fakeSet': [{'fakeData': 'fake'},
{'fakeData': 'fake'}],
},
'fakeEmptySet': [],
'fakeComplexSet': [
{'fakeSubSet': [{'fakeData': 'fake'},
{'fakeData': None}]},
{'fakeSubSet': [{'fakeData': 'fake'},
{'fakeData': 'fake'}]},
],
}
DICT_FAKE_RESULT = {
'FakeActionResponse': tools.update_dict(
DICT_FAKE_RESULT_DATA,
{'requestId': None})
}
XML_SINGLE_RESULT = '''
<CreateSnapshotResponse xmlns="http://ec2.amazonaws.com/doc/2009-11-30/">
<requestId>req-8a80bb71-1e1d-49be-819f-fba429b0ddf1</requestId>
<status>pending</status>
<description/>
<volumeId>vol-00000001</volumeId>
<volumeSize>1</volumeSize>
<progress/>
<startTime>2014-06-04T19:55:55.448117</startTime>
<ownerId/>
<snapshotId>snap-00000001</snapshotId>
</CreateSnapshotResponse>
