fog 0.9.0 → 0.10.0

data/lib/fog/storage/requests/ninefold/put_namespace.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Storage
+    class Ninefold
+      class Real
+
+        def put_namespace(namespace = '', options = {})
+          options = options.reject {|key, value| value.nil?}
+          request({
+                    :expects  => 200,
+                    :method   => 'PUT',
+                    :path     => "namespace/" + namespace,
+                    :query    => {},
+                    :parse => true
+                  }.merge(options))
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/storage/requests/rackspace/put_object.rb

@@ -7,6 +7,9 @@ module Fog
         #
         # ==== Parameters
         # * container<~String> - Name for container, should be < 256 bytes and must not contain '/'
+        # * object<~String> - Name for object
+        # * data<~String|File> - data to upload
+        # * options<~Hash> - config headers for object. Defaults to {}.
         #
         def put_object(container, object, data, options = {})
           data = Fog::Storage.parse_data(data)

data/lib/fog/storage/requests/rackspace/put_object_manifest.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Storage
+    class Rackspace
+      class Real
+
+        # Create a new object
+        #
+        # ==== Parameters
+        # * container<~String> - Name for container, should be < 256 bytes and must not contain '/'
+        # * object<~String> - Name for object
+        #
+        def put_object_manifest(container, object)
+          path = "#{URI.escape(container)}/#{URI.escape(object)}"
+          request(
+            :expects  => 201,
+            :headers  => {'X-Object-Manifest' => path},
+            :method   => 'PUT',
+            :path     => path
+          )
+        end
+
+      end
+    end
+  end
+end

data/tests/aws/models/auto_scaling/activities_tests.rb

@@ -0,0 +1,6 @@
+Shindo.tests('AWS::AutoScaling | activities', ['aws', 'auto_scaling_m']) do
+
+  pending # FIXME: activity#save is not implemented
+  collection_tests(AWS[:auto_scaling].activities, {}, false)
+
+end

data/tests/aws/models/auto_scaling/configuration_test.rb

@@ -0,0 +1,13 @@
+Shindo.tests('AWS::AutoScaling | configuration', ['aws', 'auto_scaling_m']) do
+
+  params = {
+    :id => uniq_id,
+    :image_id => 'ami-8c1fece5',
+    :instance_type => 't1.micro'
+  }
+
+  model_tests(AWS[:auto_scaling].configurations, params, false) do
+    @instance.wait_for { ready? }
+  end
+
+end

data/tests/aws/models/auto_scaling/configurations_tests.rb

@@ -0,0 +1,11 @@
+Shindo.tests('AWS::AutoScaling | configurations', ['aws', 'auto_scaling_m']) do
+
+  params = {
+    :id => uniq_id,
+    :image_id => 'ami-8c1fece5',
+    :instance_type => 't1.micro'
+  }
+
+  collection_tests(AWS[:auto_scaling].configurations, params, false)
+
+end

data/tests/aws/models/auto_scaling/instances_tests.rb

@@ -0,0 +1,6 @@
+Shindo.tests('AWS::AutoScaling | instances', ['aws', 'auto_scaling_m']) do
+
+  pending # FIXME: instance#save is not defined
+  #collection_tests(AWS[:auto_scaling].instances, {}, false)
+
+end

data/tests/aws/models/cloud_watch/metric_statistics_tests.rb

@@ -0,0 +1,51 @@
+Shindo.tests("AWS::CloudWatch | metric_statistics", ['aws', 'cloudwatch']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+    
+    instanceId = 'i-420c352f'
+    metricName = 'DiskReadBytes'
+    namespace = 'AWS/EC2'
+    startTime = (Time.now-600).iso8601
+    endTime = Time.now.iso8601
+    period = 60
+    statisticTypes = ['Minimum','Maximum','Sum','SampleCount','Average']
+    
+    tests("#all").succeeds do
+      @statistics = AWS[:cloud_watch].metric_statistics.all({'Statistics' => statisticTypes, 'StartTime' => startTime, 'EndTime' => endTime, 'Period' => period, 'MetricName' => metricName, 'Namespace' => namespace, 'Dimensions' => [{'Name' => 'InstanceId', 'Value' => instanceId}]})
+    end
+    
+    tests("#all_not_empty").returns(true) do
+      @statistics.length > 0
+    end
+    
+    new_attributes = {
+      :namespace => 'Custom/Test',
+      :metric_name => 'ModelTest',
+      :value => 9,
+      :unit => 'None'
+    }
+    tests('#new').returns(new_attributes) do
+      AWS[:cloud_watch].metric_statistics.new(new_attributes).attributes
+    end
+    
+    tests('#create').returns(new_attributes) do
+      AWS[:cloud_watch].metric_statistics.create(new_attributes).attributes
+    end
+    
+    stats_set_attributes = {
+      :namespace => 'Custom/Test',
+      :metric_name => 'ModelTest',
+      :minimum => 0,
+      :maximum => 4,
+      :sum => 10,
+      :sample_count => 5,
+      :average => 2,
+      :unit => 'None'
+    }
+    tests('#create_stats_set').returns(stats_set_attributes) do
+      AWS[:cloud_watch].metric_statistics.create(stats_set_attributes).attributes
+    end
+  end
+
+end

data/tests/aws/models/cloud_watch/metrics_tests.rb

@@ -0,0 +1,17 @@
+Shindo.tests("AWS::CloudWatch | metrics", ['aws', 'cloudwatch']) do
+
+  tests('success') do
+    pending # FIXME: the hardcoded instance id won't be available
+    tests("#all").succeeds do
+      AWS[:cloud_watch].metrics.all
+    end
+    instanceId = 'i-fd713391'
+    metricName = 'CPUUtilization'
+    namespace = 'AWS/EC2'
+    tests("#get").returns({:dimensions=>[{"Name"=>"InstanceId", "Value"=>instanceId}], :name=>metricName, :namespace=>namespace}) do
+      AWS[:cloud_watch].metrics.get(namespace, metricName, {'InstanceId' => instanceId}).attributes
+    end
+    
+  end
+
+end

data/tests/aws/{requests → models}/elb/model_tests.rb

@@ -1,23 +1,88 @@
 Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
-
+  @availability_zones = Fog::Compute[:aws].describe_availability_zones('state' => 'available').body['availabilityZoneInfo'].collect{ |az| az['zoneName'] }
+  @key_name = 'fog-test-model'
 
   tests('success') do
-    pending if Fog.mocking?
-
     tests('load_balancers') do
       tests('getting a missing elb') do
         returns(nil) { AWS[:elb].load_balancers.get('no-such-elb') }
       end
     end
 
+    tests('listeners') do
+      tests("default attributes") do
+        listener = AWS[:elb].listeners.new
+        tests('instance_port is 80').returns(80) { listener.instance_port }
+        tests('lb_port is 80').returns(80) { listener.lb_port }
+        tests('protocol is HTTP').returns('HTTP') { listener.protocol }
+        tests('policy_names is empty').returns([]) { listener.policy_names }
+      end
+
+      tests("specifying attributes") do
+        attributes = {:instance_port => 2000, :lb_port => 2001, :protocol => 'SSL', :policy_names => ['fake'] }
+        listener = AWS[:elb].listeners.new(attributes)
+        tests('instance_port is 2000').returns(2000) { listener.instance_port }
+        tests('lb_port is 2001').returns(2001) { listener.lb_port }
+        tests('protocol is SSL').returns('SSL') { listener.protocol }
+        tests('policy_names is [ fake ]').returns(['fake']) { listener.policy_names }
+      end
+    end
+
     elb = nil
     elb_id = 'fog-test'
 
     tests('create') do
-      elb = AWS[:elb].load_balancers.create(:id => elb_id)
-      tests("dns names is set").returns(true) { elb.dns_name.is_a?(String) }
-      tests("created_at is set").returns(true) { Time === elb.created_at }
-      tests("policies is empty").returns([]) { elb.policies }
+      tests('without availability zones') do
+        elb = AWS[:elb].load_balancers.create(:id => elb_id)
+        tests("availability zones are correct").returns(@availability_zones.sort) { elb.availability_zones.sort }
+        tests("dns names is set").returns(true) { elb.dns_name.is_a?(String) }
+        tests("created_at is set").returns(true) { Time === elb.created_at }
+        tests("policies is empty").returns([]) { elb.policies }
+        tests("default listener") do
+          tests("1 listener").returns(1) { elb.listeners.size }
+          tests("params").returns(AWS[:elb].listeners.new.to_params) { elb.listeners.first.to_params }
+        end
+      end
+
+      tests('with availability zones') do
+        azs = @availability_zones[1..-1]
+        elb2 = AWS[:elb].load_balancers.create(:id => "#{elb_id}-2", :availability_zones => azs)
+        tests("availability zones are correct").returns(azs.sort) { elb2.availability_zones.sort }
+        elb2.destroy
+      end
+
+      # Need to sleep here for IAM changes to propgate
+      tests('with ListenerDescriptions') do
+        @certificate = AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
+        sleep(8) unless Fog.mocking?
+        listeners = [{
+            'Listener' => {
+              'LoadBalancerPort' => 2030, 'InstancePort' => 2030, 'Protocol' => 'HTTP'
+            },
+            'PolicyNames' => []
+          }, {
+            'Listener' => {
+              'LoadBalancerPort' => 443, 'InstancePort' => 443, 'Protocol' => 'HTTPS',
+              'SSLCertificateId' => @certificate['Arn']
+            },
+            'PolicyNames' => []
+          }]
+        elb3 = AWS[:elb].load_balancers.create(:id => "#{elb_id}-3", 'ListenerDescriptions' => listeners)
+        tests('there are 2 listeners').returns(2) { elb3.listeners.count }
+        tests('instance_port is 2030').returns(2030) { elb3.listeners.first.instance_port }
+        tests('lb_port is 2030').returns(2030) { elb3.listeners.first.lb_port }
+        tests('protocol is HTTP').returns('HTTP') { elb3.listeners.first.protocol }
+        tests('protocol is HTTPS').returns('HTTPS') { elb3.listeners.last.protocol }
+        elb3.destroy
+      end
+
+      tests('with invalid Server Cert ARN').raises(Fog::AWS::IAM::NotFound) do
+        listeners = [{
+          'Listener' => {
+          'LoadBalancerPort' => 443, 'InstancePort' => 80, 'Protocol' => 'HTTPS', "SSLCertificateId" => "fakecert"}
+        }]
+        AWS[:elb].load_balancers.create(:id => "#{elb_id}-4", "ListenerDescriptions" => listeners)
+      end
     end
 
     tests('all') do
@@ -26,11 +91,11 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
     end
 
     tests('get') do
-      elb2 = AWS[:elb].load_balancers.get(elb_id)
-      tests('ids match').returns(elb_id) { elb2.id }
+      elb_get = AWS[:elb].load_balancers.get(elb_id)
+      tests('ids match').returns(elb_id) { elb_get.id }
     end
 
-    tests('createing a duplicate elb') do
+    tests('creating a duplicate elb') do
       raises(Fog::AWS::ELB::IdentifierTaken) do
         AWS[:elb].load_balancers.create(:id => elb_id, :availability_zones => ['us-east-1d'])
       end
@@ -44,7 +109,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
       raises(Fog::AWS::ELB::InvalidInstance) { elb.deregister_instances('i-00000000') }
     end
 
-    server = Compute[:aws].servers.create
+    server = Fog::Compute[:aws].servers.create
     tests('register instance') do
       begin
         elb.register_instances(server.id)
@@ -74,13 +139,13 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
     server.destroy
 
     tests('disable_availability_zones') do
-      elb.disable_availability_zones(%w{us-east-1c us-east-1d})
-      returns(%w{us-east-1a us-east-1b}) { elb.availability_zones.sort }
+      elb.disable_availability_zones(@availability_zones[1..-1])
+      returns(@availability_zones[0..0]) { elb.availability_zones.sort }
     end
 
     tests('enable_availability_zones') do
-      elb.enable_availability_zones(%w{us-east-1c us-east-1d})
-      returns(%w{us-east-1a us-east-1b us-east-1c us-east-1d}) { elb.availability_zones.sort }
+      elb.enable_availability_zones(@availability_zones[1..-1])
+      returns(@availability_zones) { elb.availability_zones.sort }
     end
 
     tests('default health check') do
@@ -107,13 +172,11 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
     end
 
     tests('listeners') do
-      default_listener_description = [{"Listener"=>{"InstancePort"=>80, "Protocol"=>"HTTP", "LoadBalancerPort"=>80}, "PolicyNames"=>[]}]
       tests('default') do
         returns(1) { elb.listeners.size }
 
         listener = elb.listeners.first
         returns([80,80,'HTTP', []]) { [listener.instance_port, listener.lb_port, listener.protocol, listener.policy_names] }
-
       end
 
       tests('#get') do
@@ -182,6 +245,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
     tests('destroy') do
       elb.destroy
     end
-  end
 
+    AWS[:iam].delete_server_certificate(@key_name)
+  end
 end

data/tests/aws/models/rds/security_group_tests.rb

@@ -8,7 +8,7 @@ Shindo.tests("AWS::RDS | security_group", ['aws', 'rds']) do
     tests("#description").returns('fog test') { @instance.description }
 
     tests("#authorize_ec2_security_group").succeeds do
-      @ec2_sec_group = Compute[:aws].security_groups.create(:name => 'fog-test', :description => 'fog test')
+      @ec2_sec_group = Fog::Compute[:aws].security_groups.create(:name => 'fog-test', :description => 'fog test')
 
       @instance.authorize_ec2_security_group(@ec2_sec_group.name)
       returns('authorizing') do

data/tests/aws/requests/auto_scaling/auto_scaling_tests.rb

@@ -0,0 +1,80 @@
+Shindo.tests('AWS::AutoScaling | auto_scaling_tests', ['aws', 'auto_scaling']) do
+  @asg_name = 'fog-test-asg'
+  @lc_name = 'fog-test-lc'
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    tests("#describe_adjustment_types").formats(AWS::AutoScaling::Formats::DESCRIBE_ADJUSTMENT_TYPES) do
+      AWS[:auto_scaling].describe_adjustment_types.body
+    end
+    tests("#describe_metric_collection_types").formats(AWS::AutoScaling::Formats::DESCRIBE_METRIC_COLLECTION_TYPES) do
+      AWS[:auto_scaling].describe_metric_collection_types.body
+    end
+    tests("#describe_scaling_process_types").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_PROCESS_TYPES) do
+      AWS[:auto_scaling].describe_scaling_process_types.body
+    end
+
+    tests("#create_launch_configuration").formats(AWS::AutoScaling::Formats::BASIC) do
+      image_id = 'ami-8c1fece5'
+      instance_type = 't1.micro'
+      #listeners = [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'http'}]
+      AWS[:auto_scaling].create_launch_configuration(image_id, instance_type, @lc_name).body
+    end
+
+    tests("#describe_launch_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_LAUNCH_CONFIGURATIONS) do
+      AWS[:auto_scaling].describe_launch_configurations().body
+    end
+    tests("#describe_launch_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_LAUNCH_CONFIGURATIONS) do
+      AWS[:auto_scaling].describe_launch_configurations('LaunchConfigurationNames' => @lc_name).body
+    end
+    tests("#describe_launch_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_LAUNCH_CONFIGURATIONS) do
+      AWS[:auto_scaling].describe_launch_configurations('LaunchConfigurationNames' => [@lc_name]).body
+    end
+
+    tests("#create_auto_scaling_group").formats(AWS::AutoScaling::Formats::BASIC) do
+      zones = ['us-east-1d']
+      max_size = 0
+      min_size = 0
+      AWS[:auto_scaling].create_auto_scaling_group(@asg_name, zones, @lc_name, max_size, min_size).body
+    end
+
+    tests("#describe_auto_scaling_groups").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_GROUPS) do
+      AWS[:auto_scaling].describe_auto_scaling_groups().body
+    end
+    tests("#describe_auto_scaling_groups").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_GROUPS) do
+      AWS[:auto_scaling].describe_auto_scaling_groups('AutoScalingGroupNames' => @asg_name).body
+    end
+    tests("#describe_auto_scaling_groups").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_GROUPS) do
+      AWS[:auto_scaling].describe_auto_scaling_groups('AutoScalingGroupNames' => [@asg_name]).body
+    end
+
+    tests("#describe_auto_scaling_instances").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_INSTANCES) do
+      AWS[:auto_scaling].describe_auto_scaling_instances().body
+    end
+
+    tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
+      AWS[:auto_scaling].describe_scaling_activities().body
+    end
+    tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
+      AWS[:auto_scaling].describe_scaling_activities('ActivityIds' => '1').body
+    end
+    tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
+      AWS[:auto_scaling].describe_scaling_activities('ActivityIds' => ['1', '2']).body
+    end
+    tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
+      AWS[:auto_scaling].describe_scaling_activities('AutoScalingGroupName' => @asg_name).body
+    end
+
+    tests("#set_desired_capacity").formats(AWS::AutoScaling::Formats::BASIC) do
+      desired_capacity = 0
+      AWS[:auto_scaling].set_desired_capacity(@asg_name, desired_capacity).body
+    end
+    tests("#delete_auto_scaling_group").formats(AWS::AutoScaling::Formats::BASIC) do
+      AWS[:auto_scaling].delete_auto_scaling_group(@asg_name).body
+    end
+    tests("#delete_launch_configuration").formats(AWS::AutoScaling::Formats::BASIC) do
+      AWS[:auto_scaling].delete_launch_configuration(@lc_name).body
+    end
+  end
+end

data/tests/aws/requests/auto_scaling/helper.rb

@@ -0,0 +1,185 @@
+class AWS
+  module AutoScaling
+    module Formats
+
+      BASIC = {
+        'ResponseMetadata' => {'RequestId' => String}
+      }
+
+      PAGINATED = {
+        'NextToken' => Fog::Nullable::String
+      }
+
+      ACTIVITY = {
+        'ActivityId' => String,
+        'AutoScalingGroupName' => String,
+        'Cause' => String,
+        'Description' => String,
+        'EndTime' => Time,
+        'Progress' => Integer,
+        'StartTime' => Time,
+        'StatusCode' => String,
+        'StatusMessage' => String
+      }
+
+      ALARM = {
+        'AlarmARN' => String,
+        'AlarmName' => String
+      }
+
+      BLOCK_DEVICE_MAPPING = {
+        'DeviceName' => String,
+        'Ebs' => {'SnapshotId' => String, 'VolumeSize' => Integer},
+        'VirtualName' => String
+      }
+
+      ENABLED_METRIC = {
+        'Granularity' => Array,
+        'Metric' => Array
+      }
+
+      INSTANCE = {
+        'AvailabilityZone' => String,
+        'HealthStatus' => String,
+        'InstanceId' => String,
+        'LaunchConfigurationName' => String,
+        'LifecycleState' => String
+      }
+
+      SCHEDULED_UPDATE_GROUP_ACTION = {
+        'AutoScalingGroupName' => String,
+        'DesiredCapacity' => Integer,
+        'MaxSize' => Integer,
+        'MinSize' => Integer,
+        'ScheduledActionARN' => String,
+        'ScheduledActionName' => String,
+        'Time' => Time
+      }
+
+      PROCESS_TYPE = {
+        'ProcessName' => String
+      }
+
+      SUSPENDED_PROCESS = PROCESS_TYPE.merge({
+        'SuspensionReason' => String
+      })
+
+      AUTO_SCALING_GROUP = {
+        'AutoScalingGroupARN' => String,
+        'AutoScalingGroupName' => String,
+        'AvailabilityZones' => Array,
+        'CreatedTime' => Time,
+        'DefaultCooldown' => Integer,
+        'DesiredCapacity' => Integer,
+        'EnabledMetrics' => [ENABLED_METRIC],
+        'HealthCheckGracePeriod' => Integer,
+        'HealthCheckType' => String,
+        'Instances' => [INSTANCE],
+        'LaunchConfigurationName' => String,
+        'LoadBalancerNames' => Array,
+        'MaxSize' => Integer,
+        'MinSize' => Integer,
+        'PlacementGroup' => Fog::Nullable::String,
+        'SuspendedProcesses' => [SUSPENDED_PROCESS],
+        'VPCZoneIdentifier' => Fog::Nullable::String
+      }
+
+      AUTO_SCALING_INSTANCE_DETAILS = INSTANCE.merge({
+        'AutoScalingGroupName' => String
+      })
+
+      LAUNCH_CONFIGURATION = {
+        'BlockDeviceMappings' => [BLOCK_DEVICE_MAPPING],
+        'CreatedTime' => Time,
+        'ImageId' => String,
+        'InstanceMonitoring' => {'Enabled' => Fog::Boolean},
+        'InstanceType' => String,
+        'KernelId' => Fog::Nullable::String,
+        'KeyName' => Fog::Nullable::String,
+        'LaunchConfigurationARN' => String,
+        'LaunchConfigurationName' => String,
+        'RamdiskId' => Fog::Nullable::String,
+        'SecurityGroups' => Array,
+        'UserData' => Fog::Nullable::String
+      }
+
+      SCALING_POLICY = {
+        'AdjustmentType' => String,
+        'Alarms' => [ALARM],
+        'AutoScalingGroupName' => String,
+        'Cooldown' => Integer,
+        'PolicyARN' => String,
+        'PolicyName' => String,
+        'ScalingAdjustment' => Integer
+      }
+
+      DESCRIBE_ADJUSTMENT_TYPES = BASIC.merge({
+        'DescribeAdjustmentTypesResult' => {
+          'AdjustmentTypes' => [{'AdjustmentType' => String}]
+        }
+      })
+
+      DESCRIBE_AUTO_SCALING_GROUPS = BASIC.merge({
+        'DescribeAutoScalingGroupsResult' => PAGINATED.merge({
+          'AutoScalingGroups' => [AUTO_SCALING_GROUP],
+        })
+      })
+
+      DESCRIBE_AUTO_SCALING_INSTANCES = BASIC.merge({
+        'DescribeAutoScalingInstancesResult' => PAGINATED.merge({
+          'AutoScalingInstances' => [AUTO_SCALING_INSTANCE_DETAILS],
+        })
+      })
+
+      DESCRIBE_LAUNCH_CONFIGURATIONS = BASIC.merge({
+        'DescribeLaunchConfigurationsResult' => PAGINATED.merge({
+          'LaunchConfigurations' => [LAUNCH_CONFIGURATION],
+        })
+      })
+
+      DESCRIBE_METRIC_COLLECTION_TYPES = BASIC.merge({
+        'DescribeMetricCollectionTypesResult' => {
+          'Granularities' => [{'Granularity' => String}],
+          'Metrics' => [{'Metric' => String}]
+        }
+      })
+
+      DESCRIBE_POLICIES = BASIC.merge({
+        'DescribePoliciesResult' => PAGINATED.merge({
+          'ScalingPolicies' => [SCALING_POLICY]
+        })
+      })
+
+      DESCRIBE_SCALING_ACTIVITIES = BASIC.merge({
+        'DescribeScalingActivitiesResult' => PAGINATED.merge({
+          'Activities' => [ACTIVITY],
+        })
+      })
+
+      DESCRIBE_SCALING_PROCESS_TYPES = BASIC.merge({
+        'DescribeScalingProcessTypesResult' => {
+          'Processes' => [PROCESS_TYPE]
+        }
+      })
+
+      DESCRIBE_SCHEDULED_ACTIONS = BASIC.merge({
+        'DescribeScheduledActionsResult' => PAGINATED.merge({
+          'ScheduledUpdateGroupActions' => [SCHEDULED_UPDATE_GROUP_ACTION]
+        })
+      })
+
+      PUT_SCALING_POLICY = BASIC.merge({
+        'PutScalingPolicyResult' => {
+          'PolicyARN' => String
+        }
+      })
+
+      TERMINATE_INSTANCE_IN_AUTO_SCALING_GROUP = BASIC.merge({
+        'TerminateInstanceInAutoScalingGroupResult' => {
+          'Activity' => [ACTIVITY]
+        }
+      })
+
+    end
+  end
+end