def test_unknown_asg(self):
logger.debug('TestInitMachineState.test_unknown_asg')
stepfns.asg_helper = Mock(**{'describe_asg.return_value': {}})
expected_msg = 'AutoScaling Group does not exist'
(state_machine_dict,
msg) = stepfns.init_machine_state(launch_notification)
self.assertDictEqual(state_machine_dict, {})
self.assertEqual(msg, expected_msg)
def test_unknown_notification(self):
logger.debug('TestInitMachineState.test_unknown_notification')
stepfns.asg_helper = Mock(
**{'describe_asg.return_value': self.asg_dict})
for bad_notification in [{'hello': 'world'}, 'test', None]:
(state_machine_dict,
msg) = stepfns.init_machine_state(bad_notification)
self.assertDictEqual(state_machine_dict, {})
self.assertEqual(msg, 'Invalid SNS message')
def test_missing_az(self):
logger.debug('TestInitMachineState.test_malformed_notification')
stepfns.asg_helper = Mock(
**{'describe_asg.return_value': self.asg_dict})
bad_notification = copy.deepcopy(launch_notification)
del (bad_notification['Details']['Availability Zone'])
(state_machine_dict,
msg) = stepfns.init_machine_state(bad_notification)
self.assertDictEqual(state_machine_dict, {})
self.assertTrue(msg)
def test_fixed_asg(self):
logger.debug('TestInitMachineState.test_fixed_asg')
self.asg_dict['MinSize'] = 1
self.asg_dict['MaxSize'] = 1
self.asg_dict['DesiredCapacity'] = 1
stepfns.asg_helper = Mock(
**{'describe_asg.return_value': self.asg_dict})
expected_msg = 'AutoScaling Group has fixed size'
(state_machine_dict,
msg) = stepfns.init_machine_state(launch_notification)
self.assertDictEqual(state_machine_dict, {})
self.assertEqual(msg, expected_msg)
def test_malformed_notification(self):
logger.debug('TestInitMachineState.test_malformed_notification')
stepfns.asg_helper = Mock(
**{'describe_asg.return_value': self.asg_dict})
for required_key in [
'EC2InstanceId', 'AutoScalingGroupName', 'Details',
'Description'
]:
bad_notification = copy.deepcopy(launch_notification)
del (bad_notification[required_key])
(state_machine_dict,
msg) = stepfns.init_machine_state(bad_notification)
self.assertDictEqual(state_machine_dict, {})
self.assertTrue(msg)
def test_attachment_notification(self):
logger.debug('TestInitMachineState.test_attachment_notification')
stepfns.asg_helper = Mock(
**{'describe_asg.return_value': self.asg_dict})
attach_notification = copy.deepcopy(launch_notification)
attach_notification[
'Description'] = 'Attaching an existing EC2 instance: {}'.format(
attach_notification['EC2InstanceId'])
attach_notification[
'Cause'] = 'At 2018-03-05T22:04:49Z an instance was added in response to user request. Keeping the capacity at the new 1.'
# launch notifications of attached instances do not include the Subnet ID
del (attach_notification['Details']['Subnet ID'])
(state_machine_dict,
msg) = stepfns.init_machine_state(attach_notification)
self.assertDictEqual(state_machine_dict, {})
self.assertTrue(msg)
def test_asg_with_tag_overrides(self):
logger.debug('TestInitMachineState.test_asg_with_tag_overrides')
wait_s = int(random.random() * 10)
spot_req_wait_s = wait_s + 1
attach_wait_s = wait_s + 2
spot_fail_wait_s = wait_s + 3
min_protected = 2
self.asg_dict['Tags'].append({
'Key': 'spoptimize:init_sleep_interval',
'Value': '{}'.format(wait_s)
})
self.asg_dict['Tags'].append({
'Key': 'spoptimize:spot_req_sleep_interval',
'Value': '{}'.format(spot_req_wait_s)
})
self.asg_dict['Tags'].append({
'Key': 'spoptimize:spot_attach_sleep_interval',
'Value': '{}'.format(attach_wait_s)
})
self.asg_dict['Tags'].append({
'Key': 'spoptimize:spot_failure_sleep_interval',
'Value': '{}'.format(spot_fail_wait_s)
})
self.asg_dict['Tags'].append({
'Key': 'spoptimize:min_protected_instances',
'Value': '{}'.format(min_protected)
})
stepfns.asg_helper = Mock(
**{'describe_asg.return_value': self.asg_dict})
(state_machine_dict,
msg) = stepfns.init_machine_state(launch_notification)
self.assertEqual(state_machine_dict['init_sleep_interval'], wait_s)
self.assertEqual(state_machine_dict['spot_req_sleep_interval'],
spot_req_wait_s)
self.assertEqual(state_machine_dict['spot_attach_sleep_interval'],
attach_wait_s)
self.assertEqual(state_machine_dict['spot_failure_sleep_interval'],
spot_fail_wait_s)
self.assertEqual(state_machine_dict['min_protected_instances'],
min_protected)
self.assertIsNone(msg)
def test_standard_asg(self):
logger.debug('TestInitMachineState.test_standard_asg')
stepfns.asg_helper = Mock(
**{'describe_asg.return_value': self.asg_dict})
random.seed(randseed)
expected_state = state_machine_init.copy()
expected_state['autoscaling_group'] = self.asg_dict.copy()
expected_state['init_sleep_interval'] = int(
(self.asg_dict['HealthCheckGracePeriod'] *
self.asg_dict['DesiredCapacity']) + (60 * random.random()) + 30)
expected_state['spot_attach_sleep_interval'] = int(
self.asg_dict['HealthCheckGracePeriod'] + 30)
random.seed(randseed)
(state_machine_dict,
msg) = stepfns.init_machine_state(launch_notification)
self.assertDictEqual(state_machine_dict, expected_state)
self.assertGreater(
state_machine_dict['init_sleep_interval'],
self.asg_dict['HealthCheckGracePeriod'] *
self.asg_dict['DesiredCapacity'])
self.assertIsNone(msg)