def test_wait_healthy(self):
"""Health check should return true when target registers as healthy."""
target_group = TargetGroup(self._target_group['TargetGroupArn'])
ami_id = self._ec2_mock.default_image()
instance = Ec2.create_instance(ami_id)
target_group.add_instance(instance)
self.assertTrue(target_group.wait_healthy(instance))
def test_remove_non_grouped_instance_should_fail(self):
"""Removing an instance not in the target group should fail."""
ami_id = self._ec2_mock.default_image()
instance = Ec2.create_instance(ami_id)
target_group = TargetGroup(self._target_group['TargetGroupArn'])
with self.assertRaises(ElbException):
target_group.remove_instance(instance)
def test_healthy_instance_check(self):
"""All instances should report back as healthy."""
target_group = TargetGroup(self._target_group['TargetGroupArn'])
instance_ids = [ec2.id() for ec2 in target_group.instances()]
healthy_ids = [ec2.id() for ec2 in target_group.healthy_instances()]
self.assertEqual(set(instance_ids), set(healthy_ids))
def test_add_terminated_instance_failure(self):
"""Adding a non-ready instance should fail."""
ami_id = self._ec2_mock.default_image()
instance = Ec2.create_instance(ami_id)
instance.terminate()
target_group = TargetGroup(self._target_group['TargetGroupArn'])
with self.assertRaises(ElbException):
target_group.add_instance(instance)
def test_instance_retrievable(self):
"""Target group should return the instances currently registered."""
target_group = TargetGroup(self._target_group['TargetGroupArn'])
mock_instances = [instance['InstanceId'] for instance in \
self._ec2_mock.instances()]
tg_instances = [instance.id() for instance in target_group.instances()]
self.assertEqual(set(tg_instances), set(mock_instances))
def test_is_unhealthy(self):
"""Test that an instance that is not in the group doesn't report as
healthy.
"""
target_group = TargetGroup(self._target_group['TargetGroupArn'])
ami_id = self._ec2_mock.default_image()
instance = Ec2.create_instance(ami_id)
self.assertFalse(target_group.is_healthy(instance))
def test_load_target_group(self):
"""Target Group should load with api pulled data."""
target_group = TargetGroup(
TargetGroupArn=self._target_group['TargetGroupArn']
)
self.assertEqual(target_group._tg_data['TargetGroupArn'],
self._target_group['TargetGroupArn']
)
self.assertEqual(target_group._tg_data['TargetGroupName'],
self._target_group['TargetGroupName']
)
def test_remove_instance(self):
"""Removing an instance should remove it from the target group."""
target_group = TargetGroup(self._target_group['TargetGroupArn'])
instances = target_group.instances()
target_group.remove_instance(instances[0])
self.assertEqual(len(target_group.instances()),
self._ec2_mock.INSTANCE_COUNT - 1
)
self.assertNotIn(instances[0].id(), [ec2.id() for ec2 in
target_group.instances()]
)
def test_add_instance(self):
"""Registering an instance should add it to the target group."""
ami_id = self._ec2_mock.images()[0]
instance = Ec2.create_instance(ami_id)
target_group = TargetGroup(self._target_group['TargetGroupArn'])
target_group.add_instance(instance)
self.assertEqual(target_group.count(), self._ec2_mock.INSTANCE_COUNT + 1)
self.assertIn(instance.id(),
[ec2.id() for ec2 in target_group.instances()]
)
def test_from_load_balancer(self):
"""We should retrieve a TargetGroup object when passing it's parent
load balancer.
"""
subnets = self._ec2_mock._client.describe_subnets()['Subnets'][:1]
elb = self._client.create_load_balancer(Name="TestLb",
Subnets=[subnet['SubnetId'] for subnet in subnets]
)['LoadBalancers'][0]
self._client.create_listener(LoadBalancerArn=elb['LoadBalancerArn'],
Protocol='HTTP', Port=80, DefaultActions=({
"Type": 'forward',
"TargetGroupArn": self._target_group['TargetGroupArn']
},))
target_group = TargetGroup.from_load_balancer(elb['LoadBalancerArn'])
self.assertIsInstance(target_group, TargetGroup)
self.assertEqual(target_group.arn(), \
self._target_group['TargetGroupArn']
)
self._client.delete_load_balancer(LoadBalancerArn=elb['LoadBalancerArn'])
def setUp(self):
self._target_group_mock.setUp()
self._target_group = TargetGroup(
self._target_group_mock.target_group()['TargetGroupArn']
)
class TargetGroupTest(unittest.TestCase):
@classmethod
def setUpClass(self):
"""Init class test objects."""
self._target_group_mock = MockTargetGroupHelper()
self._ec2_mock = MockEc2Helper()
self._new_ami = self._ec2_mock.images()[2]
def setUp(self):
self._target_group_mock.setUp()
self._target_group = TargetGroup(
self._target_group_mock.target_group()['TargetGroupArn']
)
def tearDown(self):
self._target_group_mock.tearDown()
def test_get_old_ami_instances(self):
"""Only instances with old ami should be fetched from target group."""
deployer = Deployer(self._target_group)
ami = self._ec2_mock.default_image()
instances = deployer._get_ami_instances(ami)
self.assertEqual(set((ami,)), \
set([instance.ami() for instance in instances])
)
new_ec2 = Ec2.create_instance(self._new_ami)
self._target_group.add_instance(new_ec2)
instances = deployer._get_ami_instances(ami)
self.assertEqual(set((ami,)), \
set([instance.ami() for instance in instances])
)
def test_roll_in(self):
"""A single instance with the new ami should be added to the target
group on roll in.
"""
deployer = Deployer(self._target_group)
deployer._roll_in(self._new_ami)
self.assertEqual(self._target_group.count(),
self._ec2_mock.INSTANCE_COUNT + 1
)
self.assertIn(self._new_ami, [instance.ami() \
for instance in self._target_group.healthy_instances()
])
def test_roll_out(self):
"""An instance should be removed from the target group on rollout."""
deployer = Deployer(self._target_group)
instance = Ec2(self._ec2_mock.instances()[0]['InstanceId'])
deployer._roll_out(instance)
self.assertNotIn(instance.id(),
[ec2.id() for ec2 in self._target_group.healthy_instances()]
)
self.assertEqual(self._target_group.count(), \
self._ec2_mock.INSTANCE_COUNT -1
)
def test_clean_up(self):
"""An instance drained from the target group should be terminated."""
deployer = Deployer(self._target_group)
instance = Ec2(self._ec2_mock.instances()[0]['InstanceId'])
deployer._roll_out(instance)
deployer._clean_up((instance,), wait_interval=0)
self.assertIn(instance.state(),
(Ec2.STATE_SHUTTING_DOWN, Ec2.STATE_TERMINATED,)
)
def test_clean_up_healthy_instance_fails(self):
"""Attempting to terminate a healthy instance should throw an
exception.
"""
deployer = Deployer(self._target_group)
instance = Ec2(self._ec2_mock.instances()[0]['InstanceId'])
with self.assertRaises(DeployerException):
deployer._clean_up((instance,), wait_interval=0)
def test_deploy(self):
"""All old ami instances should be replaced with instances of the new
ami.
"""
deployer = Deployer(self._target_group)
old_instances = self._target_group.instances()
deployer.deploy(self._ec2_mock.default_image(), self._new_ami)
# correct number of healthy instances
self.assertEqual(len(self._target_group.healthy_instances()),
self._ec2_mock.INSTANCE_COUNT
)
# all healthy instances are running the new ami
self.assertEqual(set((self._new_ami,)),
set([ec2.ami() for ec2 in self._target_group.healthy_instances()])
)
# all old instances are terminated
self.assertEqual(set([ec2.state() for ec2 in old_instances]),
set((Ec2.STATE_TERMINATED,))
)
# only 3 instances are left running in the mock
self.assertEqual(len(self._ec2_mock.instances()), \
self._ec2_mock.INSTANCE_COUNT
)
def test_instance_count(self):
"""Target Group should have 3 instances registered."""
target_group = TargetGroup(self._target_group['TargetGroupArn'])
self.assertEqual(target_group.count(), self._ec2_mock.INSTANCE_COUNT)
def test_load_target_group_fails_with_bad_arn(self):
"""Target Group should fail when bad arn is passed."""
with self.assertRaises(ElbException):
TargetGroup('naughtyarn')
def test_is_healthy(self):
"""Test that an instance that should be healthy reports as healthy."""
target_group = TargetGroup(self._target_group['TargetGroupArn'])
self.assertTrue(target_group.is_healthy(target_group.instances()[0]))