fog-aws 0.0.5

data/tests/models/storage/version_tests.rb

@@ -0,0 +1,52 @@
+Shindo.tests("Storage[:aws] | version", ["aws"]) do
+
+  file_attributes = {
+      :key => 'fog_file_tests',
+      :body => lorem_file,
+      :public => true
+  }
+
+  directory_attributes = {
+      :key => uniq_id('fogfilestests')
+  }
+
+  @directory = Fog::Storage[:aws].directories.create(directory_attributes)
+  @directory.versioning = true
+
+  model_tests(@directory.files, file_attributes, Fog.mocking?) do
+
+    @version_instance = @instance.versions.first
+    @directory.service.put_object(@directory.key, @instance.key, 'second version content')
+
+    tests("#file") do
+      tests("#file should return the object associated with the version").returns(@version_instance.version) do
+        @version_instance.file.version
+      end
+    end
+
+    tests("#delete_marker") do
+      tests("#delete_marker should be false if the version isn't a DeleteMarker'").returns(false) do
+        @version_instance.delete_marker
+      end
+
+      tests("#delete_marker should be true if the version is a DeleteMarker'").returns(true) do
+        @instance.destroy
+
+        @instance.versions.all.first.delete_marker
+      end
+    end
+
+    tests("#destroy") do
+      tests("#destroy removes the specific version").returns(false) do
+        @version_instance.destroy
+
+        @instance.versions.all.map(&:version).include?(@version_instance.version)
+      end
+    end
+
+  end
+
+  @directory.versions.each(&:destroy)
+  @directory.destroy
+
+end

data/tests/models/storage/versions_tests.rb

@@ -0,0 +1,56 @@
+Shindo.tests("Storage[:aws] | versions", ["aws"]) do
+
+  file_attributes = {
+      :key => 'fog_file_tests',
+      :body => lorem_file,
+      :public => true
+  }
+
+  directory_attributes = {
+      :key => uniq_id('fogfilestests')
+  }
+
+  model_tests(Fog::Storage[:aws].directories, directory_attributes, Fog.mocking?) do
+    @instance.versioning = true
+
+    versions = []
+    versions << @instance.service.put_object(@instance.key, 'one', 'abcde').headers['x-amz-version-id']
+
+    puts versions.first
+
+    versions << @instance.service.put_object(@instance.key, 'one', '32423').headers['x-amz-version-id']
+    versions << @instance.service.delete_object(@instance.key, 'one').headers['x-amz-version-id']
+    versions.reverse!
+
+    puts versions.first
+
+    versions << @instance.service.put_object(@instance.key, 'two', 'aoeu').headers['x-amz-version-id']
+
+    tests('#versions') do
+      tests('#versions.size includes versions (including DeleteMarkers) for all keys').returns(4) do
+        @instance.versions.all.size
+      end
+
+      tests('#versions returns the correct versions').returns(versions) do
+        @instance.versions.all.map(&:version)
+      end
+    end
+
+    tests("#all") do
+      tests("#all for a directory returns all versions, regardless of key").returns(versions) do
+        @instance.versions.all.map(&:version)
+      end
+
+      tests("#all for file returns only versions for that file").returns(1) do
+        @instance.files.get('two').versions.all.map(&:version).size
+      end
+
+      tests("#all for file returns only versions for that file").returns(versions.last) do
+        @instance.files.get('two').versions.all.map(&:version).first
+      end
+    end
+
+    @instance.versions.each(&:destroy)
+  end
+
+end

data/tests/parsers/elb/describe_load_balancers.rb

@@ -0,0 +1,65 @@
+require 'fog/xml'
+require 'fog/aws/parsers/elb/describe_load_balancers'
+
+DESCRIBE_LOAD_BALANCERS_RESULT = <<-EOF
+<DescribeLoadBalancersResponse
+xmlns="http://elasticloadbalancing.amazonaws.com/doc/2012-06-01/">
+  <DescribeLoadBalancersResult>
+    <LoadBalancerDescriptions>
+      <member>
+        <SecurityGroups/>
+        <CreatedTime>2013-08-01T15:47:20.930Z</CreatedTime>
+        <LoadBalancerName>fog-test-elb</LoadBalancerName>
+        <HealthCheck>
+          <Interval>30</Interval>
+          <Target>TCP:80</Target>
+          <HealthyThreshold>10</HealthyThreshold>
+          <Timeout>5</Timeout>
+          <UnhealthyThreshold>2</UnhealthyThreshold>
+        </HealthCheck>
+        <ListenerDescriptions>
+          <member>
+            <PolicyNames/>
+            <Listener>
+              <Protocol>HTTP</Protocol>
+              <LoadBalancerPort>80</LoadBalancerPort>
+              <InstanceProtocol>HTTP</InstanceProtocol>
+              <InstancePort>80</InstancePort>
+            </Listener>
+          </member>
+        </ListenerDescriptions>
+        <Instances/>
+        <Policies>
+          <AppCookieStickinessPolicies/>
+          <OtherPolicies/>
+          <LBCookieStickinessPolicies/>
+        </Policies>
+        <AvailabilityZones>
+          <member>us-east-1a</member>
+        </AvailabilityZones>
+        <CanonicalHostedZoneName>fog-test-elb-1965660309.us-east-1.elb.amazonaws.com</CanonicalHostedZoneName>
+        <CanonicalHostedZoneNameID>Z3DZXE0Q79N41H</CanonicalHostedZoneNameID>
+        <Scheme>internet-facing</Scheme>
+        <SourceSecurityGroup>
+          <OwnerAlias>amazon-elb</OwnerAlias>
+          <GroupName>amazon-elb-sg</GroupName>
+        </SourceSecurityGroup>
+        <DNSName>fog-test-elb-1965660309.us-east-1.elb.amazonaws.com</DNSName>
+        <BackendServerDescriptions/>
+        <Subnets/>
+      </member>
+    </LoadBalancerDescriptions>
+  </DescribeLoadBalancersResult>
+  <ResponseMetadata>
+    <RequestId>a6ea2117-fac1-11e2-abd3-1740ab4ef14e</RequestId>
+  </ResponseMetadata>
+</DescribeLoadBalancersResponse>
+EOF
+
+Shindo.tests('AWS::ELB | parsers | describe_load_balancers', ['aws', 'elb', 'parser']) do
+  tests('parses the xml').formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCERS) do
+    parser = Nokogiri::XML::SAX::Parser.new(Fog::Parsers::AWS::ELB::DescribeLoadBalancers.new)
+    parser.parse(DESCRIBE_LOAD_BALANCERS_RESULT)
+    parser.document.response
+  end
+end

data/tests/requests/auto_scaling/auto_scaling_tests.rb

@@ -0,0 +1,77 @@
+Shindo.tests('AWS::AutoScaling | auto_scaling_tests', ['aws', 'auto_scaling']) do
+  @asg_name = 'fog-test-asg'
+  @lc_name = 'fog-test-lc'
+
+  tests('success') do
+    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'}]
+      Fog::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
+      Fog::AWS[:auto_scaling].describe_launch_configurations().body
+    end
+    tests("#describe_launch_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_LAUNCH_CONFIGURATIONS) do
+      Fog::AWS[:auto_scaling].describe_launch_configurations('LaunchConfigurationNames' => @lc_name).body
+    end
+    tests("#describe_launch_configurations").formats(AWS::AutoScaling::Formats::DESCRIBE_LAUNCH_CONFIGURATIONS) do
+      Fog::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
+      Fog::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
+      Fog::AWS[:auto_scaling].describe_auto_scaling_groups().body
+    end
+    tests("#describe_auto_scaling_groups").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_GROUPS) do
+      Fog::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
+      Fog::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
+      Fog::AWS[:auto_scaling].describe_auto_scaling_instances().body
+    end
+
+    tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
+      pending if Fog.mocking?
+      Fog::AWS[:auto_scaling].describe_scaling_activities().body
+    end
+    tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
+      pending if Fog.mocking?
+      Fog::AWS[:auto_scaling].describe_scaling_activities('ActivityIds' => '1').body
+    end
+    tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
+      pending if Fog.mocking?
+      Fog::AWS[:auto_scaling].describe_scaling_activities('ActivityIds' => ['1', '2']).body
+    end
+    tests("#describe_scaling_activities").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_ACTIVITIES) do
+      pending if Fog.mocking?
+      Fog::AWS[:auto_scaling].describe_scaling_activities('AutoScalingGroupName' => @asg_name).body
+    end
+
+    tests("#set_desired_capacity").formats(AWS::AutoScaling::Formats::BASIC) do
+      desired_capacity = 0
+      Fog::AWS[:auto_scaling].set_desired_capacity(@asg_name, desired_capacity).body
+    end
+    tests("#delete_auto_scaling_group").formats(AWS::AutoScaling::Formats::BASIC) do
+      Fog::AWS[:auto_scaling].delete_auto_scaling_group(@asg_name, 'ForceDelete' => true).body
+    end
+
+    tests("#delete_auto_scaling_group that does not exists").raises(Fog::AWS::AutoScaling::ValidationError) do
+      Fog::AWS[:auto_scaling].delete_auto_scaling_group("group that does not exist")
+    end
+
+    tests("#delete_launch_configuration").formats(AWS::AutoScaling::Formats::BASIC) do
+      Fog::AWS[:auto_scaling].delete_launch_configuration(@lc_name).body
+    end
+  end
+end

data/tests/requests/auto_scaling/describe_types_tests.rb

@@ -0,0 +1,102 @@
+Shindo.tests('AWS::AutoScaling | describe types requests', ['aws', 'auto_scaling']) do
+
+  tests('success') do
+
+    tests("#describe_adjustment_types").formats(AWS::AutoScaling::Formats::DESCRIBE_ADJUSTMENT_TYPES) do
+      body = Fog::AWS[:auto_scaling].describe_adjustment_types.body
+
+      [ 'ChangeInCapacity',
+        'ExactCapacity',
+        'PercentChangeInCapacity'
+      ].each do |v|
+        returns(true, "AdjustmentTypes contains #{v}") do
+          body['DescribeAdjustmentTypesResult']['AdjustmentTypes'].any? {|t| t['AdjustmentType'] == v}
+        end
+      end
+
+      body
+    end
+
+    tests("#describe_auto_scaling_notification_types").formats(AWS::AutoScaling::Formats::DESCRIBE_AUTO_SCALING_NOTIFICATION_TYPES) do
+      body = Fog::AWS[:auto_scaling].describe_auto_scaling_notification_types.body
+
+      [ 'autoscaling:EC2_INSTANCE_LAUNCH',
+        'autoscaling:EC2_INSTANCE_LAUNCH_ERROR',
+        'autoscaling:EC2_INSTANCE_TERMINATE',
+        'autoscaling:EC2_INSTANCE_TERMINATE_ERROR',
+        'autoscaling:TEST_NOTIFICATION'
+      ].each do |v|
+        returns(true, "AutoScalingNotificationTypes contains #{v}") do
+          body['DescribeAutoScalingNotificationTypesResult']['AutoScalingNotificationTypes'].include?(v)
+        end
+      end
+
+      body
+    end
+
+    tests("#describe_metric_collection_types").formats(AWS::AutoScaling::Formats::DESCRIBE_METRIC_COLLECTION_TYPES) do
+      body = Fog::AWS[:auto_scaling].describe_metric_collection_types.body
+
+      [ 'GroupDesiredCapacity',
+        'GroupInServiceInstances',
+        'GroupMaxSize',
+        'GroupMinSize',
+        'GroupPendingInstances',
+        'GroupTerminatingInstances',
+        'GroupTotalInstances'
+      ].each do |v|
+        returns(true, "Metrics contains #{v}") do
+          body['DescribeMetricCollectionTypesResult']['Metrics'].any? {|t| t['Metric'] == v}
+        end
+      end
+
+      [ '1Minute'
+      ].each do |v|
+        returns(true, "Granularities contains #{v}") do
+          body['DescribeMetricCollectionTypesResult']['Granularities'].any? {|t| t['Granularity'] == v}
+        end
+      end
+
+      body
+    end
+
+    tests("#describe_scaling_process_types").formats(AWS::AutoScaling::Formats::DESCRIBE_SCALING_PROCESS_TYPES) do
+      body = Fog::AWS[:auto_scaling].describe_scaling_process_types.body
+
+      [ 'AZRebalance',
+        'AddToLoadBalancer',
+        'AlarmNotification',
+        'HealthCheck',
+        'Launch',
+        'ReplaceUnhealthy',
+        'ScheduledActions',
+        'Terminate'
+      ].each do |v|
+        returns(true, "Processes contains #{v}") do
+          body['DescribeScalingProcessTypesResult']['Processes'].any? {|t| t['ProcessName'] == v}
+        end
+      end
+
+      body
+    end
+
+    tests("#describe_termination_policy_types").formats(AWS::AutoScaling::Formats::DESCRIBE_TERMINATION_POLICY_TYPES) do
+      body = Fog::AWS[:auto_scaling].describe_termination_policy_types.body
+
+      [ 'ClosestToNextInstanceHour',
+        'Default',
+        'NewestInstance',
+        'OldestInstance',
+        'OldestLaunchConfiguration'
+      ].each do |v|
+        returns(true, "TerminationPolicyTypes contains #{v}") do
+          body['DescribeTerminationPolicyTypesResult']['TerminationPolicyTypes'].include?(v)
+        end
+      end
+
+      body
+    end
+
+  end
+
+end

data/tests/requests/auto_scaling/helper.rb

@@ -0,0 +1,228 @@
+class AWS
+  module AutoScaling
+    module Formats
+      BASIC = {
+        'ResponseMetadata' => {'RequestId' => String}
+      }
+
+      PAGINATED = {
+        'NextToken' => Fog::Nullable::String
+      }
+
+      ACTIVITY = {
+        'ActivityId' => String,
+        'AutoScalingGroupName' => String,
+        'Cause' => Fog::Nullable::String,
+        'Description' => String,
+        'EndTime' => Time,
+        'Progress' => Integer,
+        'StartTime' => Time,
+        'StatusCode' => String,
+        'StatusMessage' => Fog::Nullable::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
+      }
+
+      NOTIFICATION_CONFIGURATION = {
+        'AutoScalingGroupName' => String,
+        'NotificationType' => String,
+        'TopicARN' => String
+      }
+
+      SCHEDULED_UPDATE_GROUP_ACTION = {
+        'AutoScalingGroupName' => String,
+        'DesiredCapacity' => Integer,
+        'EndTime' => Time,
+        'MaxSize' => Integer,
+        'MinSize' => Integer,
+        'Recurrence' => String,
+        'ScheduledActionARN' => String,
+        'ScheduledActionName' => String,
+        'StartTime' => Time,
+      }
+
+      PROCESS_TYPE = {
+        'ProcessName' => String
+      }
+
+      SUSPENDED_PROCESS = PROCESS_TYPE.merge({
+        'SuspensionReason' => String
+      })
+
+      TAG_DESCRIPTION = {
+        'Key' => String,
+        'PropagateAtLaunch' => Fog::Boolean,
+        'ResourceId' => String,
+        'ResourceType' => String,
+        'Value' => Fog::Nullable::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,
+        'Status' => Fog::Nullable::String,
+        'SuspendedProcesses' => [SUSPENDED_PROCESS],
+        'Tags' => [TAG_DESCRIPTION],
+        'TerminationPolicies' => [String],
+        '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,
+        'SpotPrice' => Fog::Nullable::String,
+        'SecurityGroups' => Array,
+        'UserData' => Fog::Nullable::String
+      }
+
+      SCALING_POLICY = {
+        'AdjustmentType' => String,
+        'Alarms' => [ALARM],
+        'AutoScalingGroupName' => String,
+        'Cooldown' => Integer,
+        'MinAdjustmentStep' => 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_AUTO_SCALING_NOTIFICATION_TYPES = BASIC.merge({
+        'DescribeAutoScalingNotificationTypesResult' => {
+          'AutoScalingNotificationTypes' => [String]
+        }
+      })
+
+      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_NOTIFICATION_CONFIGURATIONS = BASIC.merge({
+        'DescribeNotificationConfigurationsResult' => PAGINATED.merge({
+          'NotificationConfigurations' => [NOTIFICATION_CONFIGURATION]
+        })
+      })
+
+      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]
+        })
+      })
+
+      DESCRIBE_TAGS = BASIC.merge({
+        'DescribeTagsResult' => PAGINATED.merge({
+          'Tags' => [TAG_DESCRIPTION]
+        })
+      })
+
+      DESCRIBE_TERMINATION_POLICY_TYPES = BASIC.merge({
+        'DescribeTerminationPolicyTypesResult' => {
+          'TerminationPolicyTypes' => [String]
+        }
+      })
+
+      PUT_SCALING_POLICY = BASIC.merge({
+        'PutScalingPolicyResult' => {
+          'PolicyARN' => String
+        }
+      })
+
+      TERMINATE_INSTANCE_IN_AUTO_SCALING_GROUP = BASIC.merge({
+        'TerminateInstanceInAutoScalingGroupResult' => {
+          'Activity' => [ACTIVITY]
+        }
+      })
+    end
+  end
+end