def test_cleanup(self):
self.route_table_service.get_all_route_tables = Mock(
return_value=[Mock(), Mock()])
vpc = self.vpc_serv.find_vpc_for_reservation()
self.cleanup_operation.cleanup(
ec2_session=self.ec2_session,
s3_session=self.s3_session,
aws_ec2_data_model=self.aws_ec2_data_model,
reservation_id=self.reservation_id,
logger=Mock(),
actions=[NetworkAction()],
ec2_client=Mock())
self.assertTrue(
self.vpc_serv.find_vpc_for_reservation.called_with(
self.ec2_session, self.reservation_id))
self.assertTrue(
self.key_pair_serv.remove_key_pair_for_reservation_in_s3.
called_with(self.s3_session, self.aws_ec2_data_model,
self.reservation_id))
self.assertTrue(self.vpc_serv.delete_all_instances.called_with(vpc))
self.assertTrue(
self.vpc_serv.remove_all_security_groups.called_with(vpc))
self.assertTrue(self.vpc_serv.remove_all_subnets.called_with(vpc))
self.assertTrue(self.vpc_serv.remove_all_peering.called_with(vpc))
self.assertTrue(self.vpc_serv.delete_vpc.called_with(vpc))
self.route_table_service.get_all_route_tables.assert_called_once_with(
ec2_session=self.ec2_session,
vpc_id=self.aws_ec2_data_model.aws_management_vpc_id)
self.assertEquals(
self.route_table_service.delete_blackhole_routes.call_count, 2)
def test_execute_sets_tags(self):
# Arrange
def return_public_tag_with_value(*args, **kwargs):
return {'Key': TagNames.IsPublic, 'Value': args[0]}
actions = [
NetworkAction(id="1",
connection_params=PrepareSubnetParams(
cidr="1.2.3.4/24", alias="MySubnet"))
]
self.reservation.reservation_id = "123"
subnet = Mock()
self.subnet_service.get_first_or_none_subnet_from_vpc = Mock(
return_value=subnet)
is_public_tag = Mock()
self.tag_service.get_is_public_tag = Mock(return_value=is_public_tag)
default_tags = [Mock()]
self.tag_service.get_default_tags = Mock(return_value=default_tags)
# Act
self.executor.execute(actions)
# Assert
default_tags.append(is_public_tag)
self.tag_service.set_ec2_resource_tags.assert_called_once_with(
subnet, default_tags)
def parse_network_actions_data(actions_data):
"""
:param [dict] actions_data:
:rtype list[NetworkAction]
"""
if not isinstance(actions_data, list):
return None
parsed_data = []
for action in actions_data:
network_action = NetworkAction()
network_action.id = action["actionId"]
network_action.type = action["type"]
network_action.connection_params = ConnectionParamsParser.parse(
action)
parsed_data.append(network_action)
return parsed_data if (len(parsed_data) > 0) else None
def test_execute_with_wrong_action_type(self):
# Arrange
actions = [
NetworkAction(id="1", connection_params=PrepareNetworkParams())
]
# Act
with self.assertRaises(Exception) as error:
self.executor.execute(actions)
# Assert
self.assertEqual(error.exception.message,
"Not all actions are PrepareSubnetActions")
def test_execute_sets_private_subnet_to_private_routing_table(self):
# Arrange
actions = [
NetworkAction(id="1",
connection_params=PrepareSubnetParams(
cidr="1.2.3.4/24", is_public=False))
]
# Act
self.executor.execute(actions)
# Assert
self.subnet_service.set_subnet_route_table.assert_called_once()
def test_cleanup_no_vpc(self):
vpc_serv = Mock()
vpc_serv.find_vpc_for_reservation = Mock(return_value=None)
result = CleanupConnectivityOperation(vpc_serv, self.key_pair_serv, self.route_table_service) \
.cleanup(
ec2_session=self.ec2_session,
s3_session=self.s3_session,
aws_ec2_data_model=self.aws_ec2_data_model,
reservation_id=self.reservation_id,
ec2_client=Mock(),
actions=[NetworkAction()],
logger=Mock())
self.assertFalse(result.success)
def test_execute_with_no_vpc(self):
# Arrange
actions = [
NetworkAction(id="1", connection_params=PrepareSubnetParams())
]
self.vpc_service.find_vpc_for_reservation = Mock(return_value=None)
self.vpc_service.get_active_vpcs_count = Mock(return_value=None)
self.reservation.reservation_id = "123"
# Act
with self.assertRaises(Exception) as error:
self.executor.execute(actions)
# Assert
self.assertEqual(error.exception.message,
"VPC for reservation 123 not found.")
def test_execute_gets_existing_subnet_and_no_wait(self):
# Arrange
actions = [
NetworkAction(
id="1",
connection_params=PrepareSubnetParams(cidr="1.2.3.4/24"))
]
subnet = Mock()
subnet.subnet_id = "123"
self.subnet_service.get_first_or_none_subnet_from_vpc = Mock(
return_value=subnet)
# Act
result = self.executor.execute(actions)[0]
# Assert
self.assertEqual(result.subnetId, "123")
self.subnet_waiter.wait.assert_not_called()
def test_execute_creates_new_subnet_and_wait(self):
# Arrange
actions = [
NetworkAction(
id="1",
connection_params=PrepareSubnetParams(cidr="1.2.3.4/24"))
]
self.subnet_service.get_first_or_none_subnet_from_vpc = Mock(
return_value=None)
subnet = Mock()
subnet.subnet_id = "456"
self.subnet_service.create_subnet_nowait = Mock(return_value=subnet)
# Act
result = self.executor.execute(actions)[0]
# Assert
self.assertEqual(result.subnetId, "456")
self.subnet_waiter.wait.assert_called_once()