rackspace-fog 1.4.2

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

@@ -0,0 +1,81 @@
+class AWS
+  module ELB
+    module Formats
+
+      BASIC = {
+        'ResponseMetadata' => {'RequestId' => String}
+      }
+
+      LOAD_BALANCER = {
+        "AvailabilityZones" => Array,
+        "CanonicalHostedZoneName" => String,
+        "CanonicalHostedZoneNameID" => String,
+        "CreatedTime" => Time,
+        "DNSName" => String,
+        "HealthCheck" => {"HealthyThreshold" => Integer, "Timeout" => Integer, "UnhealthyThreshold" => Integer, "Interval" => Integer, "Target" => String},
+        "Instances" => Array,
+        "ListenerDescriptions" => Array,
+        "LoadBalancerName" => String,
+        "Policies" => {"LBCookieStickinessPolicies" => Array, "AppCookieStickinessPolicies" => Array},
+        "SourceSecurityGroup" => {"GroupName" => String, "OwnerAlias" => String},
+        "Scheme" => String
+      }
+
+      CREATE_LOAD_BALANCER = BASIC.merge({
+        'CreateLoadBalancerResult' => { 'DNSName' => String }
+      })
+
+      DESCRIBE_LOAD_BALANCERS = BASIC.merge({
+        'DescribeLoadBalancersResult' => {'LoadBalancerDescriptions' => [LOAD_BALANCER]}
+      })
+
+      POLICY_ATTRIBUTE_DESCRIPTION = {
+        "AttributeName" => String,
+        "AttributeValue" => String
+      }
+
+      POLICY = {
+        "PolicyAttributeDescriptions" => [POLICY_ATTRIBUTE_DESCRIPTION],
+        "PolicyName" => String,
+        "PolicyTypeName" => String
+      }
+
+      DESCRIBE_LOAD_BALANCER_POLICIES = BASIC.merge({
+        'DescribeLoadBalancerPoliciesResult' => { 'PolicyDescriptions' => [POLICY] }
+      })
+
+      POLICY_ATTRIBUTE_TYPE_DESCRIPTION = {
+        "AttributeName" => String,
+        "AttributeType" => String,
+        "Cardinality" => String,
+        "DefaultValue" => String,
+        "Description" => String
+      }
+
+      POLICY_TYPE = {
+        "Description" => String,
+        "PolicyAttributeTypeDescriptions" => [POLICY_ATTRIBUTE_TYPE_DESCRIPTION],
+        "PolicyTypeName" => String
+      }
+
+      DESCRIBE_LOAD_BALANCER_POLICY_TYPES = BASIC.merge({
+        'DescribeLoadBalancerPolicyTypesResult' => { 'PolicyTypeDescriptions' => [POLICY_TYPE] }
+      })
+
+      CONFIGURE_HEALTH_CHECK = BASIC.merge({
+        'ConfigureHealthCheckResult' => {'HealthCheck' => {
+        'Target' => String,
+        'Interval' => Integer,
+        'Timeout' => Integer,
+        'UnhealthyThreshold' => Integer,
+        'HealthyThreshold' => Integer
+      }}
+      })
+
+      DELETE_LOAD_BALANCER = BASIC.merge({
+        'DeleteLoadBalancerResult' =>  NilClass
+      })
+
+    end
+  end
+end

data/tests/aws/requests/elb/listener_tests.rb

@@ -0,0 +1,68 @@
+Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
+  @load_balancer_id = 'fog-test-listener'
+  @key_name = 'fog-test'
+
+  tests('success') do
+    Fog::AWS[:elb].create_load_balancer(['us-east-1a'], @load_balancer_id, [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'HTTP'}])
+    @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
+
+    tests("#create_load_balancer_listeners").formats(AWS::ELB::Formats::BASIC) do
+      listeners = [
+        {'Protocol' => 'TCP','InstanceProtocol' => 'TCP', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => @certificate['Arn']},
+        {'Protocol' => 'HTTP', 'LoadBalancerPort' => 80, 'InstancePort' => 80}
+      ]
+      response = Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
+      response
+    end
+
+    tests("#delete_load_balancer_listeners").formats(AWS::ELB::Formats::BASIC) do
+      ports = [80, 443]
+      Fog::AWS[:elb].delete_load_balancer_listeners(@load_balancer_id, ports).body
+    end
+
+    tests("#create_load_balancer_listeners with non-existant SSL certificate") do
+      listeners = [
+        {'Protocol' => 'HTTPS', 'InstanceProtocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => 'non-existant'},
+      ]
+      raises(Fog::AWS::IAM::NotFound) { Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners) }
+    end
+
+    tests("#create_load_balancer_listeners with invalid SSL certificate").raises(Fog::AWS::IAM::NotFound) do
+      sleep 8 unless Fog.mocking?
+      listeners = [
+        {'Protocol' => 'HTTPS', 'InstanceProtocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => "#{@certificate['Arn']}fake"},
+      ]
+      Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
+    end
+
+    # This is sort of fucked up, but it may or may not fail, thanks AWS
+    tests("#create_load_balancer_listeners with SSL certificate").formats(AWS::ELB::Formats::BASIC) do
+      sleep 8 unless Fog.mocking?
+      listeners = [
+        {'Protocol' => 'HTTPS', 'InstanceProtocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => @certificate['Arn']},
+      ]
+      Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
+    end
+
+    tests("#set_load_balancer_listener_ssl_certificate").formats(AWS::ELB::Formats::BASIC) do
+      Fog::AWS[:elb].set_load_balancer_listener_ssl_certificate(@load_balancer_id, 443, @certificate['Arn']).body
+    end
+
+    tests("#create_load_balancer_listeners with invalid Protocol and InstanceProtocol configuration").raises(Fog::AWS::ELB::ValidationError) do
+      listeners = [
+        {'Protocol' => 'HTTP', 'InstanceProtocol' => 'TCP', 'LoadBalancerPort' => 80, 'InstancePort' => 80},
+      ]
+      Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
+    end
+
+    tests("#create_load_balancer_listeners with valid Protocol and InstanceProtocol configuration").formats(AWS::ELB::Formats::BASIC) do
+      listeners = [
+        {'Protocol' => 'HTTP', 'InstanceProtocol' => 'HTTPS', 'LoadBalancerPort' => 80, 'InstancePort' => 80},
+      ]
+      Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners).body
+    end
+
+    Fog::AWS[:iam].delete_server_certificate(@key_name)
+    Fog::AWS[:elb].delete_load_balancer(@load_balancer_id)
+  end
+end

data/tests/aws/requests/elb/load_balancer_tests.rb

@@ -0,0 +1,61 @@
+Shindo.tests('AWS::ELB | load_balancer_tests', ['aws', 'elb']) do
+  @load_balancer_id = 'fog-test-elb'
+  @key_name = 'fog-test'
+
+  tests('success') do
+    @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
+
+    tests("#create_load_balancer").formats(AWS::ELB::Formats::CREATE_LOAD_BALANCER) do
+      zones = ['us-east-1a']
+      listeners = [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'HTTP'}]
+      Fog::AWS[:elb].create_load_balancer(zones, @load_balancer_id, listeners).body
+    end
+
+    tests("#describe_load_balancers").formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCERS) do
+      Fog::AWS[:elb].describe_load_balancers.body
+    end
+
+    tests('#describe_load_balancers with bad lb') do
+      raises(Fog::AWS::ELB::NotFound) { Fog::AWS[:elb].describe_load_balancers('LoadBalancerNames' => 'none-such-lb') }
+    end
+
+    tests("#describe_load_balancers with SSL listener") do
+      sleep 5 unless Fog.mocking?
+      listeners = [
+        {'Protocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => @certificate['Arn']},
+      ]
+      Fog::AWS[:elb].create_load_balancer_listeners(@load_balancer_id, listeners)
+      response = Fog::AWS[:elb].describe_load_balancers('LoadBalancerNames' => @load_balancer_id).body
+      tests("SSLCertificateId is set").returns(@certificate['Arn']) do
+        listeners = response["DescribeLoadBalancersResult"]["LoadBalancerDescriptions"].first["ListenerDescriptions"]
+        listeners.find {|l| l["Listener"]["Protocol"] == 'HTTPS' }["Listener"]["SSLCertificateId"]
+      end
+    end
+
+    tests("#configure_health_check").formats(AWS::ELB::Formats::CONFIGURE_HEALTH_CHECK) do
+      health_check = {
+        'Target' => 'HTTP:80/index.html',
+        'Interval' => 10,
+        'Timeout' => 5,
+        'UnhealthyThreshold' => 2,
+        'HealthyThreshold' => 3
+      }
+
+      Fog::AWS[:elb].configure_health_check(@load_balancer_id, health_check).body
+    end
+
+    tests("#delete_load_balancer").formats(AWS::ELB::Formats::DELETE_LOAD_BALANCER) do
+      Fog::AWS[:elb].delete_load_balancer(@load_balancer_id).body
+    end
+
+    tests("#delete_load_balancer when non existant").formats(AWS::ELB::Formats::DELETE_LOAD_BALANCER) do
+      Fog::AWS[:elb].delete_load_balancer('non-existant').body
+    end
+
+    tests("#delete_load_balancer when already deleted").formats(AWS::ELB::Formats::DELETE_LOAD_BALANCER) do
+      Fog::AWS[:elb].delete_load_balancer(@load_balancer_id).body
+    end
+
+    Fog::AWS[:iam].delete_server_certificate(@key_name)
+  end
+end

data/tests/aws/requests/elb/policy_tests.rb

@@ -0,0 +1,54 @@
+Shindo.tests('AWS::ELB | policy_tests', ['aws', 'elb']) do
+  @load_balancer_id = 'fog-test-policies'
+
+  tests('success') do
+    listeners = [{'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'HTTP'}]
+    Fog::AWS[:elb].create_load_balancer(['us-east-1a'], @load_balancer_id, listeners)
+
+    tests("#create_app_cookie_stickiness_policy").formats(AWS::ELB::Formats::BASIC) do
+      cookie, policy = 'fog-app-cookie', 'fog-app-policy'
+      Fog::AWS[:elb].create_app_cookie_stickiness_policy(@load_balancer_id, policy, cookie).body
+    end
+
+    tests("#create_lb_cookie_stickiness_policy with expiry").formats(AWS::ELB::Formats::BASIC) do
+      policy = 'fog-lb-expiry'
+      expiry = 300
+      Fog::AWS[:elb].create_lb_cookie_stickiness_policy(@load_balancer_id, policy, expiry).body
+    end
+
+    tests("#create_lb_cookie_stickiness_policy without expiry").formats(AWS::ELB::Formats::BASIC) do
+      policy = 'fog-lb-no-expiry'
+      Fog::AWS[:elb].create_lb_cookie_stickiness_policy(@load_balancer_id, policy).body
+    end
+
+    tests("#describe_load_balancer_policy_types").formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCER_POLICY_TYPES) do
+      @policy_types = Fog::AWS[:elb].describe_load_balancer_policy_types.body
+    end
+
+    tests("#create_load_balancer_policy").formats(AWS::ELB::Formats::BASIC) do
+      policy = 'fog-policy'
+      Fog::AWS[:elb].create_load_balancer_policy(@load_balancer_id, policy, 'PublicKeyPolicyType', {'PublicKey' => AWS::IAM::SERVER_CERT_PUBLIC_KEY}).body
+    end
+
+    tests("#describe_load_balancer_policies").formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCER_POLICIES) do
+      Fog::AWS[:elb].describe_load_balancer_policies(@load_balancer_id).body
+    end
+
+    tests("#delete_load_balancer_policy").formats(AWS::ELB::Formats::BASIC) do
+      policy = 'fog-lb-no-expiry'
+      Fog::AWS[:elb].delete_load_balancer_policy(@load_balancer_id, policy).body
+    end
+
+    tests("#set_load_balancer_policies_of_listener adds policy").formats(AWS::ELB::Formats::BASIC) do
+      port, policies = 80, ['fog-lb-expiry']
+      Fog::AWS[:elb].set_load_balancer_policies_of_listener(@load_balancer_id, port, policies).body
+    end
+
+    tests("#set_load_balancer_policies_of_listener removes policy").formats(AWS::ELB::Formats::BASIC) do
+      port = 80
+      Fog::AWS[:elb].set_load_balancer_policies_of_listener(@load_balancer_id, port, []).body
+    end
+
+    Fog::AWS[:elb].delete_load_balancer(@load_balancer_id)
+  end
+end

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

@@ -0,0 +1,172 @@
+class AWS
+
+  module EMR
+
+    module Formats
+      BASIC = {
+        'RequestId' => String
+      }
+
+      RUN_JOB_FLOW = BASIC.merge({
+        'JobFlowId' => String
+      })
+      
+      ADD_INSTANCE_GROUPS = {
+        'JobFlowId' => String,
+        'InstanceGroupIds' => Array
+      }
+      
+      SIMPLE_DESCRIBE_JOB_FLOW = {
+        'JobFlows' => [{
+          'Name' => String,
+          'BootstrapActions' => {
+            'ScriptBootstrapActionConfig' => {
+              'Args' => Array
+            }
+          },
+          'ExecutionStatusDetail' => {
+            'CreationDateTime' => String,
+            'State' => String,
+            'LastStateChangeReason' => String
+          },
+          'Steps' => [{
+            'ActionOnFailure' => String,
+            'Name' => String,
+            'StepConfig' => {
+              'HadoopJarStepConfig' => {
+                'MainClass' => String,
+                'Jar' => String,
+                'Args' => Array,
+                'Properties' => Array
+              }
+            },
+            'ExecutionStatusDetail' => {
+              'CreationDateTime' => String,
+              'State' => String
+            }
+          }],
+          'JobFlowId' => String,
+          'Instances' => {
+            'InstanceCount' => String,
+            'NormalizedInstanceHours' => String,
+            'KeepJobFlowAliveWhenNoSteps' => String,
+            'Placement' => {
+              'AvailabilityZone' => String
+            },
+            'MasterInstanceType' => String,
+            'SlaveInstanceType' => String,
+            'InstanceGroups' => Array,
+            'TerminationProtected' => String,
+            'HadoopVersion' => String
+          }
+        }]
+      }
+      
+      JOB_FLOW_WITHOUT_CHANGE = {
+        'JobFlows' => [{
+          'Name' => String,
+          'BootstrapActions' => {
+            'ScriptBootstrapActionConfig' => {
+              'Args' => Array
+            }
+          },
+          'ExecutionStatusDetail' => {
+            'CreationDateTime' => String,
+            'State' => String,
+            'LastStateChangeReason' => NilClass
+          },
+          'Steps' => [{
+            'ActionOnFailure' => String,
+            'Name' => String,
+            'StepConfig' => {
+              'HadoopJarStepConfig' => {
+                'MainClass' => String,
+                'Jar' => String,
+                'Args' => Array,
+                'Properties' => Array
+              }
+            },
+            'ExecutionStatusDetail' => {
+              'CreationDateTime' => String,
+              'State' => String
+            }
+          }],
+          'JobFlowId' => String,
+          'Instances' => {
+            'InstanceCount' => String,
+            'NormalizedInstanceHours' => String,
+            'KeepJobFlowAliveWhenNoSteps' => String,
+            'Placement' => {
+              'AvailabilityZone' => String
+            },
+            'MasterInstanceType' => String,
+            'SlaveInstanceType' => String,
+            'InstanceGroups' => Array,
+            'TerminationProtected' => String,
+            'HadoopVersion' => String
+          }
+        }]
+      }
+      
+      DESCRIBE_JOB_FLOW_WITH_INSTANCE_GROUPS = {
+        'JobFlows' => [{
+          'Name' => String,
+          'BootstrapActions' => {
+            'ScriptBootstrapActionConfig' => {
+              'Args' => Array
+            }
+          },
+          'ExecutionStatusDetail' => {
+            'CreationDateTime' => String,
+            'State' => String,
+            'LastStateChangeReason' => NilClass
+          },
+          'Steps' => [{
+            'ActionOnFailure' => String,
+            'Name' => String,
+            'StepConfig' => {
+              'HadoopJarStepConfig' => {
+                'MainClass' => String,
+                'Jar' => String,
+                'Args' => Array,
+                'Properties' => Array
+              }
+            },
+            'ExecutionStatusDetail' => {
+              'CreationDateTime' => String,
+              'State' => String
+            }
+          }],
+          'JobFlowId' => String,
+          'Instances' => {
+            'InstanceCount' => String,
+            'NormalizedInstanceHours' => String,
+            'KeepJobFlowAliveWhenNoSteps' => String,
+            'Placement' => {
+              'AvailabilityZone' => String
+            },
+            'InstanceGroups' => [{
+              'Name' => String,
+              'InstanceRole' => String,
+              'CreationDateTime' => String,
+              'LastStateChangeReason' => nil,
+              'InstanceGroupId' => String,
+              'Market' => String,
+              'InstanceType' => String,
+              'State' => String,
+              'InstanceRunningCount' => String,
+              'InstanceRequestCount' => String
+            }],
+            'MasterInstanceType' => String,
+            'SlaveInstanceType' => String,
+            'InstanceGroups' => Array,
+            'TerminationProtected' => String,
+            'HadoopVersion' => String
+          }
+        }]
+      }
+
+    end
+  end
+
+end

data/tests/aws/requests/emr/instance_group_tests.rb

@@ -0,0 +1,106 @@
+Shindo.tests('AWS::EMR | instance groups', ['aws', 'emr']) do
+
+  pending if Fog.mocking?
+
+  @job_flow_name = "fog_job_flow_#{Time.now.to_f.to_s.gsub('.','')}"
+
+  @job_flow_options = {
+    'Instances' => {
+      'MasterInstanceType' => 'm1.small',
+      'SlaveInstanceType' => 'm1.small',
+      'InstanceCount' => 2,
+      'Placement' => {
+        'AvailabilityZone' => 'us-east-1a'
+      },
+      'KeepJobFlowAliveWhenNoSteps' => false,
+      'TerminationProtected' => false,
+      'HadoopVersion' => '0.20'
+    }
+  }
+
+  @job_flow_steps = {
+    'Steps' => [{
+      'Name' => 'Dummy streaming job',
+      'ActionOnFailure' => 'CONTINUE',
+      'HadoopJarStep' => {
+        'Jar' => '/home/hadoop/contrib/streaming/hadoop-streaming.jar',
+        'MainClass' => nil,
+        'Args' => %w(-input s3n://elasticmapreduce/samples/wordcount/input -output hdfs:///examples/output/2011-11-03T090856 -mapper s3n://elasticmapreduce/samples/wordcount/wordSplitter.py -reducer aggregate)
+      }
+    }]
+  }
+
+  @instance_group_name = "fog_instance_group_#{Time.now.to_f.to_s.gsub('.','')}"
+  @instance_groups = {
+    'InstanceGroups' => [{
+      'Name' => @instance_group_name,
+      'InstanceRole' => 'TASK',
+      'InstanceType' => 'm1.small',
+      'InstanceCount' => 2
+    }]
+  }
+
+  result = AWS[:emr].run_job_flow(@job_flow_name, @job_flow_options).body
+  @job_flow_id = result['JobFlowId']
+
+  tests('success') do
+
+    tests("#add_instance_groups").formats(AWS::EMR::Formats::ADD_INSTANCE_GROUPS) do
+      pending if Fog.mocking?
+
+      result = AWS[:emr].add_instance_groups(@job_flow_id, @instance_groups).body
+
+      @instance_group_id = result['InstanceGroupIds'].first
+
+      result
+    end
+
+    tests("#describe_job_flows_with_instance_groups").formats(AWS::EMR::Formats::DESCRIBE_JOB_FLOW_WITH_INSTANCE_GROUPS) do
+      pending if Fog.mocking?
+
+      result = AWS[:emr].describe_job_flows('JobFlowIds' => [@job_flow_id]).body
+
+      result
+    end
+
+    tests("#modify_instance_groups").formats(AWS::EMR::Formats::BASIC) do
+      pending if Fog.mocking?
+
+      # Add a step so the state doesn't go directly from STARTING to SHUTTING_DOWN
+      AWS[:emr].add_job_flow_steps(@job_flow_id, @job_flow_steps)
+
+      # Wait until job has started before modifying the instance group
+      begin
+        sleep 10
+
+        result = AWS[:emr].describe_job_flows('JobFlowIds' => [@job_flow_id]).body
+        job_flow = result['JobFlows'].first
+        state = job_flow['ExecutionStatusDetail']['State']
+        print "."
+      end while(state == 'STARTING')
+
+      # Check results
+      result = AWS[:emr].modify_instance_groups('InstanceGroups' => [{'InstanceGroupId' => @instance_group_id, 'InstanceCount' => 4}]).body
+
+      # Check the it actually modified the instance count
+      tests("modify worked?") do
+        ig_res = AWS[:emr].describe_job_flows('JobFlowIds' => [@job_flow_id]).body
+
+        matched = false
+        jf = ig_res['JobFlows'].first
+        jf['Instances']['InstanceGroups'].each do | ig |
+          if ig['InstanceGroupId'] == @instance_group_id
+            matched = true if ig['InstanceRequestCount'].to_i == 4
+          end
+        end
+
+        matched
+      end
+
+      result
+    end
+
+  end
+
+  AWS[:emr].terminate_job_flows('JobFlowIds' => [@job_flow_id])
+end