class AutoScalingBasics(EutesterTestCase): def __init__(self, extra_args= None): self.setuptestcase() self.setup_parser() if extra_args: for arg in extra_args: self.parser.add_argument(arg) self.get_args() # Setup basic nephoria object if self.args.region: self.tester = Eucaops(credpath=self.args.credpath, region=self.args.region) else: self.tester = Eucaops(credpath=self.args.credpath, config_file=self.args.config, password=self.args.password) ### Add and authorize a group for the instance self.group = self.tester.ec2.add_group(group_name="group-" + str(time.time())) self.tester.ec2.authorize_group_by_name(group_name=self.group.name ) self.tester.ec2.authorize_group_by_name(group_name=self.group.name, port=-1, protocol="icmp" ) ### Generate a keypair for the instance self.keypair = self.tester.ec2.create_keypair_and_localcert( "keypair-" + str(time.time())) self.keypath = '%s/%s.pem' % (os.curdir, self.keypair.name) self.image = self.args.emi if not self.image: self.image = self.tester.ec2.get_emi() self.address = None self.asg = None def clean_method(self): if self.asg: self.tester.wait_for_result(self.gracefully_delete, True) self.tester.autoscaling.delete_as_group(self.asg.name, force=True) self.tester.cleanup_artifacts() def AutoScalingBasics(self): ### create launch configuration self.launch_config_name = 'Test-Launch-Config-' + str(time.time()) self.tester.autoscaling.create_launch_config(name=self.launch_config_name, image_id=self.image.id, instance_type="m1.small", key_name=self.keypair.name, security_groups=[self.group.name]) ### create auto scale group self.auto_scaling_group_name = 'ASG-' + str(time.time()) self.asg = self.tester.autoscaling.create_as_group(group_name=self.auto_scaling_group_name, availability_zones=self.tester.ec2.get_zones(), launch_config=self.launch_config_name, min_size=0, max_size=5) ### Test Create and describe Auto Scaling Policy self.up_policy_name = "Up-Policy-" + str(time.time()) self.up_size = 4 self.tester.autoscaling.create_as_policy(name=self.up_policy_name, adjustment_type="ChangeInCapacity", scaling_adjustment=4, as_name=self.auto_scaling_group_name, cooldown=120) if len(self.tester.autoscaling.connection.get_all_policies(policy_names=[self.up_policy_name])) != 1: raise Exception('Auto Scaling policies: ' + self.up_policy_name +' not created') self.down_policy_name = "Down-Policy-" + str(time.time()) self.down_size = -50 self.tester.autoscaling.create_as_policy(name=self.down_policy_name, adjustment_type="PercentChangeInCapacity", scaling_adjustment=self.down_size, as_name=self.auto_scaling_group_name, cooldown=120) if len(self.tester.autoscaling.connection.get_all_policies(policy_names=[self.down_policy_name])) != 1: raise Exception('Auto Scaling policies: ' + self.down_policy_name +' not created') self.exact_policy_name = "Exact-Policy-" + str(time.time()) self.exact_size = 0 self.tester.autoscaling.create_as_policy(name=self.exact_policy_name, adjustment_type="ExactCapacity", scaling_adjustment=self.exact_size, as_name=self.auto_scaling_group_name, cooldown=120) if len(self.tester.autoscaling.connection.get_all_policies(policy_names=[self.exact_policy_name])) != 1: raise Exception('Auto Scaling policies: ' + self.exact_policy_name +' not created') self.debug("**** Created Auto Scaling Policies: " + self.up_policy_name + " " + self.down_policy_name + " " + self.exact_policy_name) self.tester.wait_for_result(self.scaling_activities_complete, True, timeout=180) ### Test Execute ChangeInCapacity Auto Scaling Policy self.tester.autoscaling.execute_as_policy(policy_name=self.up_policy_name, as_group=self.auto_scaling_group_name, honor_cooldown=False) if self.tester.autoscaling.describe_as_group(self.auto_scaling_group_name).desired_capacity != self.up_size: raise Exception("Auto Scale Up not executed") self.debug("Executed ChangeInCapacity policy, increased desired capacity to: " + str(self.tester.autoscaling.describe_as_group(self.auto_scaling_group_name).desired_capacity)) self.tester.autoscaling.wait_for_result(self.scaling_activities_complete, True, timeout=180) ### Test Execute PercentChangeInCapacity Auto Scaling Policy self.tester.autoscaling.execute_as_policy(policy_name=self.down_policy_name, as_group=self.auto_scaling_group_name, honor_cooldown=False) if self.tester.autoscaling.describe_as_group(self.auto_scaling_group_name).desired_capacity != 0.5 * self.up_size: raise Exception("Auto Scale down percentage not executed") self.debug("Executed PercentChangeInCapacity policy, decreased desired capacity to: " + str(self.tester.autoscaling.describe_as_group(self.auto_scaling_group_name).desired_capacity)) self.tester.autoscaling.wait_for_result(self.scaling_activities_complete, True, timeout=180) ### Test Execute ExactCapacity Auto Scaling Policy self.tester.autoscaling.execute_as_policy(policy_name=self.exact_policy_name, as_group=self.auto_scaling_group_name, honor_cooldown=False) if self.tester.autoscaling.describe_as_group(self.auto_scaling_group_name).desired_capacity != self.exact_size: raise Exception("Auto Scale down percentage not executed") self.debug("Executed ExactCapacity policy, exact capacity is: " + str(self.tester.autoscaling.describe_as_group(self.auto_scaling_group_name).desired_capacity)) self.tester.autoscaling.wait_for_result(self.scaling_activities_complete, True, timeout=180) ### Test Delete all Auto Scaling Policies self.tester.autoscaling.delete_all_policies() ### Test Delete Auto Scaling Group self.tester.autoscaling.wait_for_result(self.gracefully_delete, True) self.asg = None ### Test delete launch config self.tester.autoscaling.delete_launch_config(self.launch_config_name) def scaling_activities_complete(self): activities = self.asg.get_activities() for activity in activities: assert isinstance(activity,Activity) if activity.progress != 100: return False return True def AutoScalingInstanceBasics(self): """ This case will test DescribeAutoScalingInstances, SetInstanceHealth and TerminateInstanceInAutoScalingGroup """ pass def too_many_launch_configs_test(self): """ AWS enforces a 100 LC per account limit this nephoria_unit_tests what happens if we create more """ for i in range(101): self.launch_config_name = 'Test-Launch-Config-' + str(i + 1) self.tester.autoscaling.create_launch_config(name=self.launch_config_name, image_id=self.image.id) if len(self.tester.autoscaling.describe_launch_config()) > 100: raise Exception("More then 100 launch configs exist in 1 account") for lc in self.tester.autoscaling.describe_launch_config(): self.tester.autoscaling.delete_launch_config(lc.name) def too_many_policies_test(self): """ AWS enforces a 25 policy per account limit this nephoria_unit_tests what happens if we create more """ launch_config_name = 'LC-' + str(time.time()) self.tester.autoscaling.create_launch_config(name=launch_config_name, image_id=self.image.id, instance_type="m1.small", key_name=self.keypair.name, security_groups=[self.group.name]) asg_name = 'ASG-' + str(time.time()) self.asg = self.tester.autoscaling.create_as_group(group_name=asg_name, launch_config=launch_config_name, availability_zones=self.tester.autoscaling.get_zones(), min_size=0, max_size=5) for i in range(26): policy_name = "Policy-" + str(i + 1) self.tester.autoscaling.create_as_policy(name=policy_name, adjustment_type="ExactCapacity", as_name=asg_name, scaling_adjustment=0, cooldown=120) if len(self.tester.autoscaling.autoscale.get_all_policies()) > 25: raise Exception("More than 25 policies exist for 1 auto scaling group") self.tester.autoscaling.wait_for_result(self.gracefully_delete, True) self.asg = None def too_many_as_groups(self): """ AWS imposes a 20 ASG/acct limit """ pass def clear_all(self): """ remove ALL scaling policies, auto scaling groups and launch configs """ self.tester.autoscaling.delete_all_policies() self.tester.autoscaling.delete_all_autoscaling_groups() self.tester.autoscaling.delete_all_launch_configs() def change_config(self): ### create initial launch configuration first_launch_config = 'First-Launch-Config-' + str(time.time()) self.tester.autoscaling.create_launch_config(name=first_launch_config, image_id=self.image.id, instance_type="m1.small") # create a replacement LC with different instance type second_launch_config = 'Second-Launch-Config-' + str(time.time()) self.tester.autoscaling.create_launch_config(name=second_launch_config, image_id=self.image.id, instance_type="m1.large") ### create auto scale group auto_scaling_group_name = 'ASG-' + str(time.time()) self.asg = self.tester.autoscaling.create_as_group(group_name=auto_scaling_group_name, launch_config=first_launch_config, availability_zones=self.tester.ec2.get_zones(), min_size=1, max_size=4, desired_capacity=1) assert isinstance(self.asg, AutoScalingGroup) self.tester.autoscaling.wait_for_result(self.tester.autoscaling.wait_for_instances, True, timeout=360, group_name=self.asg.name, tester=self.tester) self.tester.autoscaling.update_as_group(group_name=self.asg.name, launch_config=second_launch_config, availability_zones=self.tester.ec2.get_zones(), min_size=1, max_size=4) ### Set desired capacity new_desired = 2 self.asg.set_capacity(new_desired) self.tester.autoscaling.wait_for_result(self.tester.autoscaling.wait_for_instances, True, timeout=360, group_name=self.asg.name, number=new_desired, tester=self.tester) last_instance = self.tester.ec2.get_instances( idstring=self.tester.autoscaling.get_last_instance_id(tester=self.tester))[0] assert last_instance.instance_type == "m1.large" ### Delete Auto Scaling Group self.tester.autoscaling.wait_for_result(self.gracefully_delete, True) self.asg = None ### delete launch configs self.tester.autoscaling.delete_launch_config(first_launch_config) self.tester.autoscaling.delete_launch_config(second_launch_config) def gracefully_delete(self, asg = None): if not asg: asg = self.asg assert isinstance(asg, AutoScalingGroup) try: self.tester.autoscaling.delete_as_group(name=asg.name, force=True) except BotoServerError, e: if e.status == 400 and e.reason == "ScalingActivityInProgress": return False return True
class CloudWatchBasics(EutesterTestCase): def __init__(self, extra_args= None): self.setuptestcase() self.setup_parser() self.parser.add_argument('--clean_on_exit', action='store_true', default=True, help='Boolean, used to flag whether to run clean up method after running test list)') if extra_args: for arg in extra_args: self.parser.add_argument(arg) self.get_args() ### Setup basic nephoria object if self.args.region: self.tester = CWops( credpath=self.args.credpath, region=self.args.region) else: self.tester = Eucaops(config_file=self.args.config, password=self.args.password, credpath=self.args.credpath) self.start_time = str(int(time.time())) self.zone = self.tester.ec2.get_zones() self.namespace = 'Namespace-' + self.start_time self.keypair = self.tester.ec2.create_keypair_and_localcert() self.group = self.tester.ec2.add_group() ### Setup AutoScaling self.setUpAutoscaling() ### Create Dimensions used in nephoria_unit_tests self.instanceDimension = newDimension('InstanceId', self.instanceid) self.volumeDimension = newDimension('VolumeId', self.volume.id) self.autoScalingDimension = newDimension('AutoScalingGroupName', self.auto_scaling_group_name) ### Setup Alarms self.setUpAlarms() ### Wait for metrics to populate, timeout 30 minute self.tester.wait_for_result(self.IsMetricsListPopulated, result=True, timeout=1800) def clean_method(self): self.cleanUpAutoscaling() self.tester.cleanup_artifacts() self.tester.ec2.delete_keypair(self.keypair) pass def get_time_window(self, end=None, **kwargs): if not end: end = datetime.datetime.utcnow() start = end - datetime.timedelta(**kwargs) return (start,end) def print_timeseries_for_graphite(self, timeseries): for datapoint in timeseries: print 'graph.Namespace-1361426618 ' + str(int(datapoint['Average'])) + ' ' + \ str((datapoint['Timestamp'] - datetime.datetime(1970,1,1)).total_seconds()) def PutDataGetStats(self): assert self.testAwsReservedNamspaces() seconds_to_put_data = 120 metric_data = 1 time_string = str(int(time.time())) metric_name = "Metric-" + time_string incrementing = True while datetime.datetime.now().second != 0: self.tester.debug("Waiting for minute edge") self.tester.sleep(1) start = datetime.datetime.utcnow() - datetime.timedelta(seconds=seconds_to_put_data) for i in xrange(seconds_to_put_data): timestamp = start + datetime.timedelta(seconds=i) self.tester.debug("Adding metric: {metric} to namespace: {namespace} with value {value} at {timestamp}" .format(metric=metric_name, namespace=self.namespace, value=metric_data, timestamp=timestamp)) self.tester.cloudwatch.put_metric_data(self.namespace, [metric_name],[metric_data],timestamp=timestamp) if metric_data == 600 or metric_data == 0: incrementing = not incrementing if incrementing: metric_data += 1 else: metric_data -= 1 end = start + datetime.timedelta(seconds=seconds_to_put_data) self.tester.sleep(60) metric = self.tester.cloudwatch.list_metrics(namespace=self.namespace)[0] assert isinstance(metric,Metric) stats_array = metric.query(start_time=start, end_time=end, statistics=['Average', 'Sum', 'Maximum', 'Minimum','SampleCount'] ) assert len(stats_array) == 2 if stats_array[0]['Minimum'] == 1: first_sample = stats_array[0] second_sample = stats_array[1] else: second_sample = stats_array[0] first_sample = stats_array[1] print stats_array ##Check sample 1 assert first_sample['Maximum'] <= 60 and first_sample['Minimum'] > 0 assert first_sample['Average'] < 34 and first_sample['Average'] > 26 assert first_sample['Sum'] < 1900 and first_sample['Sum'] > 1500 assert first_sample['SampleCount'] > 50 ##Check sample 2 assert second_sample['Maximum'] <= 120 and second_sample['Minimum'] > 50 assert second_sample['Average'] < 95 and second_sample['Average'] > 80 assert second_sample['Sum'] < 6100 and second_sample['Sum'] > 4600 assert second_sample['SampleCount'] > 50 assert first_sample['Average'] < second_sample['Average'] assert first_sample['Sum'] < second_sample['Sum'] assert first_sample['Maximum'] < second_sample['Maximum'] assert first_sample['Minimum'] < second_sample['Minimum'] def ListMetrics(self, metricNames, dimension): self.debug('Get Metric list') metricList = self.tester.cloudwatch.list_metrics(dimensions=dimension) self.debug('Checking to see if list is populated at all.') assert len(metricList) > 0 self.debug('Make sure dimensions are listed.') found=False for metric in metricList: self.debug(metric.dimensions) if str(metric.dimensions).count(dimension[dimension.keys().pop()]) : self.debug('Dimension ' + dimension[dimension.keys().pop()]) found=True break assert found self.debug('Checking to see if we get all the expected instance metrics.') for metric in metricNames: assert str(metricList).count(metric['name']) > 0 self.debug('Metric ' + metric['name']) pass def checkMetricFilters(self): self.debug('Check list_metrics filtering parameters') metricList = self.tester.cloudwatch.list_metrics(namespace='AWS/EC2') assert len(metricList) > 0 metricList = self.tester.cloudwatch.list_metrics(namespace='AWS/EBS') assert len(metricList) > 0 metricList = self.tester.cloudwatch.list_metrics(namespace='NonExistent-NameSpace') assert len(metricList) == 0 metricList = self.tester.cloudwatch.list_metrics(metric_name='CPUUtilization') assert len(metricList) > 0 metricList = self.tester.cloudwatch.list_metrics(metric_name='NonExistent-Metric-Name') assert len(metricList) == 0 metricList = self.tester.cloudwatch.list_metrics(dimensions=self.instanceDimension) assert len(metricList) > 0 metricList = self.tester.cloudwatch.list_metrics(dimensions=newDimension('InstanceId','NonExistent-InstanceId')) assert len(metricList) == 0 metricList = self.tester.cloudwatch.list_metrics(dimensions=self.volumeDimension) assert len(metricList) > 0 metricList = self.tester.cloudwatch.list_metrics(dimensions=newDimension('VolumeId','NonExistent-VolumeId')) assert len(metricList) == 0 metricList = self.tester.cloudwatch.list_metrics(dimensions=newDimension('ImageId', self.image.id)) assert len(metricList) > 0 metricList = self.tester.cloudwatch.list_metrics(dimensions=newDimension('ImageId','NonExistent-imageId')) assert len(metricList) == 0 metricList = self.tester.cloudwatch.list_metrics(dimensions=newDimension('InstanceType', self.instance_type)) assert len(metricList) > 0 metricList = self.tester.cloudwatch.list_metrics(dimensions=newDimension('InstanceType','NonExistent-InstanceType')) assert len(metricList) == 0 metricList = self.tester.cloudwatch.list_metrics(dimensions=self.autoScalingDimension) assert len(metricList) > 0 metricList = self.tester.cloudwatch.list_metrics(dimensions=newDimension('AutoScalingGroupName','NonExistent-AutoScalingGroupName')) assert len(metricList) == 0 metricList = self.tester.cloudwatch.list_metrics(dimensions=self.volumeDimension) assert len(metricList) > 0 metricList = self.tester.cloudwatch.list_metrics(dimensions=newDimension('VolumeId', 'NonExistent-VolumeId')) assert len(metricList) == 0 pass def IsMetricsListPopulated(self): end = datetime.datetime.utcnow() start = end - datetime.timedelta(minutes=20) metrics1=self.tester.cloudwatch.get_metric_statistics(60,start,end,'CPUUtilization','AWS/EC2','Average',dimensions=self.instanceDimension,unit='Percent') metrics2=self.tester.cloudwatch.get_metric_statistics(60,start,end,'VolumeReadBytes','AWS/EBS','Average',dimensions=self.volumeDimension,unit='Bytes') if len(metrics1) > 0 and len(metrics2) > 0 : return True else: return False def GetMetricStatistics(self, metricNames, namespace, dimension): period = 60 end = datetime.datetime.utcnow() start = end - datetime.timedelta(minutes=20) stats = self.tester.cloudwatch.get_stats_array() ###Check to make sure we are getting all namespace metrics and statistics for i in range(len(metricNames)): values = [] for j in range(len(stats)): metricName = metricNames[i]['name'] statisticName = stats[j] unitType = metricNames[i]['unit'] metrics = self.tester.cloudwatch.get_metric_statistics(period, start, end, metricName, namespace, statisticName , dimensions=dimension, unit=unitType) ### This assures we are getting all statistics for all dimension metrics. assert int(len(metrics)) > 0 statisticValue = str(metrics[0][statisticName]) self.debug(metricName + ' : ' + statisticName + '=' + statisticValue + ' ' + unitType) values.append(statisticValue) self.tester.cloudwatch.validateStats(values) def setUpAutoscaling(self): ### setup autoscaling variables:s self.debug('Setting up AutoScaling, starting 1 instance') self.instance_type = 'm1.small' self.image = self.tester.ec2.get_emi(root_device_type='instance-store') self.launch_config_name='ASConfig' self.auto_scaling_group_name ='ASGroup' self.exact = 'ExactCapacity' self.change = 'ChangeInCapacity' self.percent = 'PercentChangeInCapacity' self.cleanUpAutoscaling() diskWrite = 'while [ 1 ];do dd if=/dev/zero of=/root/testFile bs=1M count=1; done &' diskRead = 'while [ 1 ];do dd if=/root/testFile of=/dev/null bs=1M count=1; done &' ### create launch configuration self.tester.autoscaling.create_launch_config(name= self.launch_config_name, image_id=self.image.id, instance_type=self.instance_type, key_name=self.keypair.name, security_groups=[self.group.name], instance_monitoring=True, user_data=diskWrite + ' ' + diskRead) ### create auto scale group self.tester.autoscaling.create_as_group(group_name=self.auto_scaling_group_name, availability_zones=self.zone, launch_config=self.launch_config_name, min_size=0, max_size=5, desired_capacity=1) ### create auto scale policys self.tester.autoscaling.create_as_policy(name=self.exact, adjustment_type=self.exact, scaling_adjustment=0, as_name=self.auto_scaling_group_name, cooldown=0) self.tester.autoscaling.create_as_policy(name=self.change, adjustment_type=self.change, scaling_adjustment=1, as_name=self.auto_scaling_group_name, cooldown=0) self.tester.autoscaling.create_as_policy(name=self.percent, adjustment_type=self.percent, scaling_adjustment=-50, as_name=self.auto_scaling_group_name, cooldown=0) ## Wait for the instance to go to running state. self.tester.wait_for_result(self.tester.autoscaling.wait_for_instances, True, timeout=600, group_name=self.auto_scaling_group_name, tester=self.tester) self.instanceid = self.tester.autoscaling.get_last_instance_id(tester=self.tester) instance_list = self.tester.ec2.get_instances(idstring=self.instanceid) self.instance = instance_list.pop() self.debug('ASG is now setup.') ### Create and attach a volume self.volume = self.tester.ec2.create_volume(self.zone.pop()) self.tester.ec2.attach_volume(self.instance, self.volume, '/dev/sdf' ) ### Get the newly created policies. self.policy_exact = self.tester.autoscaling.connection.get_all_policies(policy_names=[self.exact]) self.policy_change = self.tester.autoscaling.connection.get_all_policies(policy_names=[self.change]) self.policy_percent = self.tester.autoscaling.connection.get_all_policies(policy_names=[self.percent]) self.debug('AutoScaling setup Complete') def cleanUpAutoscaling(self): self.tester.cloudwatch.delete_all_alarms() self.tester.autoscaling.delete_all_policies() self.tester.autoscaling.delete_as_group(name=self.auto_scaling_group_name,force=True) self.tester.autoscaling.delete_launch_config(self.launch_config_name) def isInService(self): group = self.tester.autoscaling.describe_as_group(name=self.auto_scaling_group_name) allInService = True for instance in group.instances: if not str(instance.lifecycle_state).endswith('InService'): allInService = False break return allInService def setUpAlarms(self): metric = 'CPUUtilization' comparison = '>' threshold = 0 period = 60 evaluation_periods= 1 statistic = 'Average' ### This alarm sets the number of running instances to exactly 0 alarm_exact = self.tester.cloudwatch.metric_alarm( 'exact', metric, comparison, threshold ,period, evaluation_periods, statistic, description='TEST', namespace='AWS/EC2', dimensions=self.instanceDimension, alarm_actions=self.policy_exact.pop().policy_arn) ### This alarm sets the number of running instances to + 1 alarm_change = self.tester.cloudwatch.metric_alarm( 'change', metric, comparison, threshold ,period, evaluation_periods, statistic, description='TEST', namespace='AWS/EC2', dimensions=self.instanceDimension, alarm_actions=self.policy_change.pop().policy_arn) ### This alarm sets the number of running instances to -50% alarm_percent = self.tester.cloudwatch.metric_alarm( 'percent', metric, comparison, threshold ,period, evaluation_periods, statistic, description='TEST', namespace='AWS/EC2', dimensions=self.instanceDimension, alarm_actions=self.policy_percent.pop().policy_arn) ### put all the alarms self.tester.cloudwatch.put_metric_alarm(alarm_change) self.tester.cloudwatch.put_metric_alarm(alarm_percent) self.tester.cloudwatch.put_metric_alarm(alarm_exact) def testDesribeAlarms(self): self.debug(self.tester.cloudwatch.describe_alarms()) assert len(self.tester.cloudwatch.describe_alarms()) >= 3 ### test describe_alarms_for_metric for created alarms assert len(self.tester.cloudwatch.describe_alarms_for_metric('CPUUtilization','AWS/EC2',dimensions=self.instanceDimension)) == 3 ### There are not be any alarms created for 'DiskReadOps' assert len(self.tester.cloudwatch.describe_alarms_for_metric('DiskReadOps','AWS/EC2',dimensions=self.instanceDimension)) == 0 ### test describe_alarm_history self.debug(self.tester.cloudwatch.describe_alarm_history()) assert len(self.tester.cloudwatch.describe_alarm_history()) >= 3 pass def testAlarms(self): ### The number of running instances should equal the desired_capacity for the auto_scaling_group = (1) group = self.tester.autoscaling.describe_as_group(name=self.auto_scaling_group_name) assert len(group.instances) == 1 ### The number of running instances should still be 1 with 'exact' disabled self.tester.cloudwatch.disable_alarm_actions('exact') self.tester.cloudwatch.set_alarm_state('exact') self.tester.sleep(15) group = self.tester.autoscaling.describe_as_group(name=self.auto_scaling_group_name) assert len(group.instances) == 1 self.tester.cloudwatch.enable_alarm_actions('exact') self.debug('The number of running ' + self.auto_scaling_group_name + ' instances = 1') ### The number of running instances should equal the desired_capacity + scaling_adjustment = (2) self.tester.cloudwatch.set_alarm_state('change') self.tester.sleep(15) self.tester.wait_for_result(self.isInService,result=True, timeout=240) group = self.tester.autoscaling.describe_as_group(name=self.auto_scaling_group_name) self.debug(len(group.instances)) assert len(group.instances) == 2 self.debug('Success the number of running ' + self.auto_scaling_group_name + ' instances changed to 2') ### The number of running instances should equal the total from the previous scaling_adjustment (2) - 50% = (1) self.tester.cloudwatch.set_alarm_state('percent') self.tester.sleep(15) group = self.tester.autoscaling.describe_as_group(name=self.auto_scaling_group_name) assert len(group.instances) == 1 self.debug('Success the number of running ' + self.auto_scaling_group_name + ' instances decreased by 50%') ### This should terminate all instances in the auto_scaling_group. self.tester.cloudwatch.set_alarm_state('exact') self.tester.sleep(15) group = self.tester.autoscaling.describe_as_group(name=self.auto_scaling_group_name) assert group.instances == None self.debug('Success the number of running ' + self.auto_scaling_group_name + ' instances is exactly 0') pass def testAwsReservedNamspaces(self): try: self.tester.cloudwatch.put_metric_data('AWS/AnyName', 'TestMetricName',1) except Exception, e: if str(e).count('The value AWS/ for parameter Namespace is invalid.'): self.tester.debug('testAwsReservedNamspaces generated expected InvalidParameterValue error.') return True self.tester.debug('testAwsReservedNamspaces did not throw expected InvalidParameterValue error.' ) return False