class Fog::AWS::AutoScaling::Mock

Attributes

region[RW]

Public Class Methods

data() click to toggle source
# File lib/fog/aws/auto_scaling.rb, line 190
def self.data
  @data ||= Hash.new do |hash, region|
    owner_id = Fog::AWS::Mock.owner_id
    hash[region] = Hash.new do |region_hash, key|
      region_hash[key] = {
        :adjustment_types => [
          'ChangeInCapacity',
          'ExactCapacity',
          'PercentChangeInCapacity'
        ],
        :auto_scaling_groups => {},
        :scaling_policies => {},
        :health_states => [
          'Healthy',
          'Unhealthy'
        ],
        :launch_configurations => {},
        :metric_collection_types => {
          :granularities => [
            '1Minute'
          ],
          :metrics => [
            'GroupMinSize',
            'GroupMaxSize',
            'GroupDesiredCapacity',
            'GroupInServiceInstances',
            'GroupPendingInstances',
            'GroupTerminatingInstances',
            'GroupTotalInstances'
          ]
        },
        :notification_configurations => {},
        :notification_types => [
          'autoscaling:EC2_INSTANCE_LAUNCH',
          'autoscaling:EC2_INSTANCE_LAUNCH_ERROR',
          'autoscaling:EC2_INSTANCE_TERMINATE',
          'autoscaling:EC2_INSTANCE_TERMINATE_ERROR',
          'autoscaling:TEST_NOTIFICATION'
        ],
        :owner_id => owner_id,
        :process_types => [
          'AZRebalance',
          'AddToLoadBalancer',
          'AlarmNotification',
          'HealthCheck',
          'Launch',
          'ReplaceUnhealthy',
          'ScheduledActions',
          'Terminate'
        ],
        :termination_policy_types => [
          'ClosestToNextInstanceHour',
          'Default',
          'NewestInstance',
          'OldestInstance',
          'OldestLaunchConfiguration'
        ]
      }
    end
  end
end
new(options={}) click to toggle source
# File lib/fog/aws/auto_scaling.rb, line 256
def initialize(options={})
  @use_iam_profile = options[:use_iam_profile]
  setup_credentials(options)
  @region = options[:region] || 'us-east-1'

  Fog::AWS.validate_region!(@region)
end
reset() click to toggle source
# File lib/fog/aws/auto_scaling.rb, line 252
def self.reset
  @data = nil
end

Public Instance Methods

attach_instances(auto_scaling_group_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/attach_instances.rb, line 39
def attach_instances(auto_scaling_group_name, options = {})
  unexpected_options = options.keys - ExpectedOptions[:asg_name] - ExpectedOptions[:instance_ids]

  unless unexpected_options.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
  end

  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
attach_load_balancer_target_groups(auto_scaling_group_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/attach_load_balancer_target_groups.rb, line 37
def attach_load_balancer_target_groups(auto_scaling_group_name, options = {})
  unexpected_options = options.keys - ExpectedOptions[:attach_load_balancer_target_groups]

  unless unexpected_options.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
  end

  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
attach_load_balancers(auto_scaling_group_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/attach_load_balancers.rb, line 37
def attach_load_balancers(auto_scaling_group_name, options = {})
  unexpected_options = options.keys - ExpectedOptions[:attach_load_balancers]

  unless unexpected_options.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
  end

  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
create_auto_scaling_group(auto_scaling_group_name, availability_zones, launch_configuration_name, max_size, min_size, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/create_auto_scaling_group.rb, line 94
def create_auto_scaling_group(auto_scaling_group_name, availability_zones, launch_configuration_name, max_size, min_size, options = {})
  unexpected_options = options.keys - ExpectedOptions[:create_auto_scaling_group]
  unless unexpected_options.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
  end

  if self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::IdentifierTaken.new("AutoScalingGroup by this name already exists - A group with the name #{auto_scaling_group_name} already exists")
  end
  unless self.data[:launch_configurations].key?(launch_configuration_name)
    raise Fog::AWS::AutoScaling::ValidationError.new('Launch configuration name not found - null')
  end
  self.data[:auto_scaling_groups][auto_scaling_group_name] = {
    'AutoScalingGroupARN'     => Fog::AWS::Mock.arn('autoscaling', self.data[:owner_id], "autoScalingGroup:00000000-0000-0000-0000-000000000000:autoScalingGroupName/#{auto_scaling_group_name}", @region),
    'AutoScalingGroupName'    => auto_scaling_group_name,
    'AvailabilityZones'       => [*availability_zones],
    'CreatedTime'             => Time.now.utc,
    'DefaultCooldown'         => 300,
    'DesiredCapacity'         => 0,
    'EnabledMetrics'          => [],
    'HealthCheckGracePeriod'  => 0,
    'HealthCheckType'         => 'EC2',
    'Instances'               => [],
    'LaunchConfigurationName' => launch_configuration_name,
    'LoadBalancerNames'       => [],
    'MaxSize'                 => max_size,
    'MinSize'                 => min_size,
    'PlacementGroup'          => nil,
    'SuspendedProcesses'      => [],
    'Tags'                    => [],
    'TargetGroupARNs'         => [],
    'TerminationPolicies'     => ['Default'],
    'VPCZoneIdentifier'       => nil
  }.merge!(options)

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
create_launch_configuration(image_id, instance_type, launch_configuration_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/create_launch_configuration.rb, line 86
def create_launch_configuration(image_id, instance_type, launch_configuration_name, options = {})
  if self.data[:launch_configurations].key?(launch_configuration_name)
    raise Fog::AWS::AutoScaling::IdentifierTaken.new("Launch Configuration by this name already exists - A launch configuration already exists with the name #{launch_configuration_name}")
  end
  self.data[:launch_configurations][launch_configuration_name] = {
    'AssociatePublicIpAddress' => nil,
    'BlockDeviceMappings'     => [],
    'CreatedTime'             => Time.now.utc,
    'EbsOptimized'            => false,
    'IamInstanceProfile'      => nil,
    'ImageId'                 => image_id,
    'InstanceMonitoring'      => {'Enabled' => true},
    'InstanceType'            => instance_type,
    'KernelId'                => nil,
    'KeyName'                 => nil,
    'LaunchConfigurationARN'  => Fog::AWS::Mock.arn('autoscaling', self.data[:owner_id], "launchConfiguration:00000000-0000-0000-0000-000000000000:launchConfigurationName/#{launch_configuration_name}", @region),
    'LaunchConfigurationName' => launch_configuration_name,
    'PlacementTenancy'        => nil,
    'RamdiskId'               => nil,
    'SecurityGroups'          => [],
    'UserData'                => nil
  }.merge!(options)

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
create_or_update_tags(tags) click to toggle source
# File lib/fog/aws/requests/auto_scaling/create_or_update_tags.rb, line 48
def create_or_update_tags(tags)
  if tags.to_a.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("1 validation error detected: Value null at 'tags' failed to satisfy constraint: Member must not be null")
  end
  raise Fog::Mock::NotImplementedError
end
data() click to toggle source
# File lib/fog/aws/auto_scaling.rb, line 268
def data
  self.region_data[@aws_access_key_id]
end
delete_auto_scaling_group(auto_scaling_group_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/delete_auto_scaling_group.rb, line 38
def delete_auto_scaling_group(auto_scaling_group_name, options = {})
  unless self.data[:auto_scaling_groups].delete(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError, "The auto scaling group '#{auto_scaling_group_name}' does not exist."
  end

  self.data[:notification_configurations].delete(auto_scaling_group_name)

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
delete_launch_configuration(launch_configuration_name) click to toggle source
# File lib/fog/aws/requests/auto_scaling/delete_launch_configuration.rb, line 36
def delete_launch_configuration(launch_configuration_name)
  unless self.data[:launch_configurations].delete(launch_configuration_name)
    raise Fog::AWS::AutoScaling::NotFound, "The launch configuration '#{launch_configuration_name}' does not exist."
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
delete_notification_configuration(auto_scaling_group_name, topic_arn) click to toggle source
# File lib/fog/aws/requests/auto_scaling/delete_notification_configuration.rb, line 35
def delete_notification_configuration(auto_scaling_group_name, topic_arn)
  unless self.data[:notification_configurations].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - %s' % auto_scaling_group_name)
  end
  unless self.data[:notification_configurations][auto_scaling_group_name].key?(topic_arn)
    raise Fog::AWS::AutoScaling::ValidationError.new("Notification Topic '#{topic_arn}' doesn't exist for '#{self.data[:owner_id]}'")
  end

  self.data[:notification_configurations][auto_scaling_group_name].delete(topic_arn)
  if self.data[:notification_configurations][auto_scaling_group_name].empty?
    self.data[:notification_configurations].delete(auto_scaling_group_name)
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
delete_policy(auto_scaling_group_name, policy_name) click to toggle source
# File lib/fog/aws/requests/auto_scaling/delete_policy.rb, line 35
def delete_policy(auto_scaling_group_name, policy_name)
  unless self.data[:scaling_policies].delete(policy_name)
    raise Fog::AWS::AutoScaling::NotFound, "The scaling policy '#{policy_name}' does not exist."
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
delete_scheduled_action(auto_scaling_group_name, scheduled_action_name) click to toggle source
# File lib/fog/aws/requests/auto_scaling/delete_scheduled_action.rb, line 36
def delete_scheduled_action(auto_scaling_group_name, scheduled_action_name)
  Fog::Mock.not_implemented
end
delete_tags(tags) click to toggle source
# File lib/fog/aws/requests/auto_scaling/delete_tags.rb, line 48
def delete_tags(tags)
  if tags.to_a.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("1 validation error detected: Value null at 'tags' failed to satisfy constraint: Member must not be null")
  end
  raise Fog::Mock::NotImplementedError
end
describe_adjustment_types() click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_adjustment_types.rb, line 32
def describe_adjustment_types()
  results = { 'AdjustmentTypes' => [] }
  self.data[:adjustment_types].each do |adjustment_type|
    results['AdjustmentTypes'] << { 'AdjustmentType' => adjustment_type }
  end
  response = Excon::Response.new
  response.status = 200
  response.body = {
    'DescribeAdjustmentTypesResult' => results,
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
describe_auto_scaling_groups(options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_auto_scaling_groups.rb, line 108
def describe_auto_scaling_groups(options = {})
  results = { 'AutoScalingGroups' => [] }
  asg_set = self.data[:auto_scaling_groups]

  if !options["AutoScalingGroupNames"].nil?
    asg_set = asg_set.reject do |asg_name, asg_data|
      ![*options["AutoScalingGroupNames"]].include?(asg_name)
    end
  end

  asg_set.each do |asg_name, asg_data|
    results['AutoScalingGroups'] << {
      'AutoScalingGroupName' => asg_name
    }.merge!(asg_data)
  end
  response = Excon::Response.new
  response.status = 200
  response.body = {
    'DescribeAutoScalingGroupsResult' => results,
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
describe_auto_scaling_instances(options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_auto_scaling_instances.rb, line 69
def describe_auto_scaling_instances(options = {})
  results = { 'AutoScalingInstances' => [] }
  self.data[:auto_scaling_groups].each do |asg_name, asg_data|
    asg_data['Instances'].each do |instance|
      results['AutoScalingInstances'] << {
        'AutoScalingGroupName' => asg_name
      }.merge!(instance)
    end
  end
  response = Excon::Response.new
  response.status = 200
  response.body = {
    'DescribeAutoScalingInstancesResult' => results,
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
describe_auto_scaling_notification_types() click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_auto_scaling_notification_types.rb, line 32
def describe_auto_scaling_notification_types()
  results = {
    'AutoScalingNotificationTypes' => [],
  }
  self.data[:notification_types].each do |notification_type|
    results['AutoScalingNotificationTypes'] << notification_type
  end
  response = Excon::Response.new
  response.status = 200
  response.body = {
    'DescribeAutoScalingNotificationTypesResult' => results,
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
describe_launch_configurations(options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_launch_configurations.rb, line 85
def describe_launch_configurations(options = {})
  launch_configuration_names = options.delete('LaunchConfigurationNames')
  # even a nil object will turn into an empty array
  lc = [*launch_configuration_names]

  launch_configurations =
     if lc.any?
       lc.map do |lc_name|
         l_conf = self.data[:launch_configurations].find { |name, data| name == lc_name }
         #raise Fog::AWS::AutoScaling::NotFound unless l_conf
         l_conf[1].dup if l_conf
       end.compact
     else
       self.data[:launch_configurations].map { |lc, values| values.dup }
     end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'DescribeLaunchConfigurationsResult' => { 'LaunchConfigurations' => launch_configurations },
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
describe_metric_collection_types() click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_metric_collection_types.rb, line 34
def describe_metric_collection_types()
  results = {
    'Granularities' => [],
    'Metrics' => []
  }
  self.data[:metric_collection_types][:granularities].each do |granularity|
    results['Granularities'] << { 'Granularity' => granularity }
  end
  self.data[:metric_collection_types][:metrics].each do |metric|
    results['Metrics'] << { 'Metric' => metric }
  end
  response = Excon::Response.new
  response.status = 200
  response.body = {
    'DescribeMetricCollectionTypesResult' => results,
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
describe_notification_configurations(options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_notification_configurations.rb, line 48
def describe_notification_configurations(options = {})
  results = { 'NotificationConfigurations' => [] }
  (options['AutoScalingGroupNames']||self.data[:notification_configurations].keys).each do |asg_name|
    (self.data[:notification_configurations][asg_name]||{}).each do |topic_arn, notification_types|
      notification_types.each do |notification_type|
        results['NotificationConfigurations'] << {
          'AutoScalingGroupName' => asg_name,
          'NotificationType'     => notification_type,
          'TopicARN'             => topic_arn,
        }
      end
    end
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'DescribeNotificationConfigurationsResult' => results,
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
describe_policies(options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_policies.rb, line 73
def describe_policies(options = {})
  results = { 'ScalingPolicies' => [] }
  policy_set = self.data[:scaling_policies]

  for opt_key, opt_value in options
    if opt_key == "PolicyNames" && opt_value != nil && opt_value != ""
      policy_set = policy_set.reject do |asp_name, asp_data|
        ![*options["PolicyNames"]].include?(asp_name)
      end
    elsif opt_key == "AutoScalingGroupName" && opt_value != nil && opt_value != ""
      policy_set = policy_set.reject do |asp_name, asp_data|
        options["AutoScalingGroupName"] != asp_data["AutoScalingGroupName"]
      end
    end
  end

  policy_set.each do |asp_name, asp_data|
    results['ScalingPolicies'] << {
      'PolicyName' => asp_name
    }.merge!(asp_data)
  end
  response = Excon::Response.new
  response.status = 200
  response.body = {
    'DescribePoliciesResult' => results,
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
describe_scaling_activities(options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_scaling_activities.rb, line 76
def describe_scaling_activities(options = {})
  Fog::Mock.not_implemented
end
describe_scaling_process_types() click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_scaling_process_types.rb, line 33
def describe_scaling_process_types()
  results = { 'Processes' => [] }
  self.data[:process_types].each do |process_type|
    results['Processes'] << { 'ProcessName' => process_type }
  end
  response = Excon::Response.new
  response.status = 200
  response.body = {
    'DescribeScalingProcessTypesResult' => results,
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
describe_scheduled_actions(options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_scheduled_actions.rb, line 76
def describe_scheduled_actions(options = {})
  Fog::Mock.not_implemented
end
describe_tags(options={}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_tags.rb, line 62
def describe_tags(options={})
  raise Fog::Mock::NotImplementedError
end
describe_termination_policy_types() click to toggle source
# File lib/fog/aws/requests/auto_scaling/describe_termination_policy_types.rb, line 31
def describe_termination_policy_types()
  results = { 'TerminationPolicyTypes' => [] }
  self.data[:termination_policy_types].each do |termination_policy_type|
    results['TerminationPolicyTypes'] << termination_policy_type
  end
  response = Excon::Response.new
  response.status = 200
  response.body = {
    'DescribeTerminationPolicyTypesResult' => results,
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
detach_instances(auto_scaling_group_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/detach_instances.rb, line 47
def detach_instances(auto_scaling_group_name, options = {})
  unexpected_options = options.keys - ExpectedOptions[:asg_name] - ExpectedOptions[:instance_ids] - ExpectedOptions[:should_decrement_desired_capacity]

  unless unexpected_options.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
  end

  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
detach_load_balancer_target_groups(auto_scaling_group_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/detach_load_balancer_target_groups.rb, line 36
def detach_load_balancer_target_groups(auto_scaling_group_name, options = {})
  unexpected_options = options.keys - ExpectedOptions[:detach_load_balancer_target_groups]

  unless unexpected_options.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
  end

  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
detach_load_balancers(auto_scaling_group_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/detach_load_balancers.rb, line 41
def detach_load_balancers(auto_scaling_group_name, options = {})
  unexpected_options = options.keys - ExpectedOptions[:detach_load_balancers]

  unless unexpected_options.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
  end

  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
disable_metrics_collection(auto_scaling_group_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/disable_metrics_collection.rb, line 40
def disable_metrics_collection(auto_scaling_group_name, options = {})
  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    Fog::AWS::AutoScaling::ValidationError.new("Group #{auto_scaling_group_name} not found")
  end

  Fog::Mock.not_implemented
end
enable_metrics_collection(auto_scaling_group_name, granularity, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/enable_metrics_collection.rb, line 47
def enable_metrics_collection(auto_scaling_group_name, granularity, options = {})
  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    Fog::AWS::AutoScaling::ValidationError.new("Group #{auto_scaling_group_name} not found")
  end
  unless self.data[:metric_collection_types][:granularities].include?(granularity)
    Fog::AWS::AutoScaling::ValidationError.new('Valid metrics granularity type is: [1Minute].')
  end

  Fog::Mock.not_implemented
end
execute_policy(policy_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/execute_policy.rb, line 38
def execute_policy(policy_name, options = {})
  Fog::Mock.not_implemented
end
put_notification_configuration(auto_scaling_group_name, notification_types, topic_arn) click to toggle source
# File lib/fog/aws/requests/auto_scaling/put_notification_configuration.rb, line 39
def put_notification_configuration(auto_scaling_group_name, notification_types, topic_arn)
  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new("AutoScalingGroup name not found - #{auto_scaling_group_name}")
  end
  if notification_types.to_a.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("1 validation error detected: Value null at 'notificationTypes' failed to satisfy constraint: Member must not be null")
  end
  invalid_types = notification_types.to_a - self.data[:notification_types]
  unless invalid_types.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("&quot;#{invalid_types.first}&quot; is not a valid Notification Type.")
  end

  self.data[:notification_configurations][auto_scaling_group_name] ||= {}
  self.data[:notification_configurations][auto_scaling_group_name][topic_arn] = notification_types.to_a.uniq

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
put_scaling_policy(adjustment_type, auto_scaling_group_name, policy_name, scaling_adjustment, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/put_scaling_policy.rb, line 54
def put_scaling_policy(adjustment_type, auto_scaling_group_name, policy_name, scaling_adjustment, options = {})
  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new('Auto Scaling Group name not found - null')
  end
  self.data[:scaling_policies][policy_name] = {
    'AdjustmentType'       => adjustment_type,
    'Alarms'               => [],
    'AutoScalingGroupName' => auto_scaling_group_name,
    'Cooldown'             => 0,
    'MinAdjustmentStep'    => 0,
    'PolicyARN'            => Fog::AWS::Mock.arn('autoscaling', self.data[:owner_id], "scalingPolicy:00000000-0000-0000-0000-000000000000:autoScalingGroupName/#{auto_scaling_group_name}:policyName/#{policy_name}", self.region),
    'PolicyName'           => policy_name,
    'ScalingAdjustment'    => scaling_adjustment
  }.merge!(options)

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
put_scheduled_update_group_action(auto_scaling_group_name, scheduled_policy_name, time, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/put_scheduled_update_group_action.rb, line 58
def put_scheduled_update_group_action(auto_scaling_group_name, scheduled_policy_name, time, options = {})
  Fog::Mock.not_implemented
end
region_data() click to toggle source
# File lib/fog/aws/auto_scaling.rb, line 264
def region_data
  self.class.data[@region]
end
reset_data() click to toggle source
# File lib/fog/aws/auto_scaling.rb, line 272
def reset_data
  self.region_data.delete(@aws_access_key_id)
end
resume_processes(auto_scaling_group_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/resume_processes.rb, line 38
def resume_processes(auto_scaling_group_name, options = {})
  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new("AutoScalingGroup name not found - no such group: #{auto_scaling_group_name}")
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
set_desired_capacity(auto_scaling_group_name, desired_capacity, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/set_desired_capacity.rb, line 65
def set_desired_capacity(auto_scaling_group_name, desired_capacity, options = {})
  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
  end
  self.data[:auto_scaling_groups][auto_scaling_group_name]['DesiredCapacity'] = desired_capacity

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
set_instance_health(health_status, instance_id, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/set_instance_health.rb, line 39
def set_instance_health(health_status, instance_id, options = {})
  unless self.data[:health_states].include?(health_status)
    raise Fog::AWS::AutoScaling::ValidationError.new('Valid instance health states are: [#{self.data[:health_states].join(", ")}].')
  end

  Fog::Mock.not_implemented
end
set_instance_protection(auto_scaling_group_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/set_instance_protection.rb, line 43
def set_instance_protection(auto_scaling_group_name, options = {})
  unexpected_options = options.keys - \
    ExpectedOptions[:asg_name] - \
    ExpectedOptions[:instance_ids] - \
    ExpectedOptions[:protected_from_scale_in]

  unless unexpected_options.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
  end

  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
setup_credentials(options) click to toggle source
# File lib/fog/aws/auto_scaling.rb, line 276
def setup_credentials(options)
  @aws_access_key_id = options[:aws_access_key_id]
end
suspend_processes(auto_scaling_group_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/suspend_processes.rb, line 41
def suspend_processes(auto_scaling_group_name, options = {})
  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new("AutoScalingGroup name not found - no such group: #{auto_scaling_group_name}")
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end
terminate_instance_in_auto_scaling_group(instance_id, should_decrement_desired_capacity) click to toggle source
# File lib/fog/aws/requests/auto_scaling/terminate_instance_in_auto_scaling_group.rb, line 53
def terminate_instance_in_auto_scaling_group(instance_id, should_decrement_desired_capacity)
  Fog::Mock.not_implemented
end
update_auto_scaling_group(auto_scaling_group_name, options = {}) click to toggle source
# File lib/fog/aws/requests/auto_scaling/update_auto_scaling_group.rb, line 72
def update_auto_scaling_group(auto_scaling_group_name, options = {})
  unexpected_options = options.keys - ExpectedOptions[:update_auto_scaling_group]
  unless unexpected_options.empty?
    raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
  end

  unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
    raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
  end
  self.data[:auto_scaling_groups][auto_scaling_group_name].merge!(options)

  response = Excon::Response.new
  response.status = 200
  response.body = {
    'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
  }
  response
end