fog-aws 0.0.5

data/tests/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, 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', 'InstanceProtocol' => '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/requests/elb/load_balancer_tests.rb

@@ -0,0 +1,89 @@
+Shindo.tests('AWS::ELB | load_balancer_tests', ['aws', 'elb']) do
+  @load_balancer_id = 'fog-test-elb'
+  @key_name = 'fog-test'
+
+  tests('success') do
+    if (Fog::AWS[:iam].get_server_certificate(@key_name) rescue nil)
+      Fog::AWS[:iam].delete_server_certificate(@key_name)
+    end
+
+    @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT, 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, 'InstanceProtocol' => 'HTTP', '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("modify_load_balancer_attributes") do
+      attributes = {
+        'ConnectionDraining' => {'Enabled' => true, 'Timeout' => 600},
+        'CrossZoneLoadBalancing' => {'Enabled' => true},
+        'ConnectionSettings' => {'IdleTimeout' => 180}
+      }
+      Fog::AWS[:elb].modify_load_balancer_attributes(@load_balancer_id, attributes).body
+      response = Fog::AWS[:elb].describe_load_balancer_attributes(@load_balancer_id).
+        body['DescribeLoadBalancerAttributesResult']['LoadBalancerAttributes']
+
+      tests("ConnectionDraining is enabled") do
+        response['ConnectionDraining']['Enabled'] == true
+      end
+      tests("ConnectionDraining has a 600 second Timeout").returns(600) do
+        response['ConnectionDraining']['Timeout']
+      end
+      tests("ConnectionSettings has a 180 second IdleTimeout").returns(180) do
+        response['ConnectionSettings']['IdleTimeout']
+      end
+      tests("CrossZoneLoadBalancing is enabled") do
+        response['CrossZoneLoadBalancing']['Enabled'] == true
+      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/requests/elb/policy_tests.rb

@@ -0,0 +1,132 @@
+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("#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_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("#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") do
+      body = Fog::AWS[:elb].describe_load_balancer_policies(@load_balancer_id).body
+      formats(AWS::ELB::Formats::DESCRIBE_LOAD_BALANCER_POLICIES) { body }
+
+      # Check the result of each policy by name
+      returns({
+                "PolicyAttributeDescriptions"=>[{
+                                                  "AttributeName"=>"CookieName",
+                                                  "AttributeValue"=>"fog-app-cookie"
+                                                }],
+                "PolicyName"=>"fog-app-policy",
+                "PolicyTypeName"=>"AppCookieStickinessPolicyType"
+              }) do
+        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].find{|e| e['PolicyName'] == 'fog-app-policy' }
+      end
+
+      returns({
+                "PolicyAttributeDescriptions"=>[{
+                                                  "AttributeName"=>"CookieExpirationPeriod",
+                                                  "AttributeValue"=>"300"
+                                                }],
+                "PolicyName"=>"fog-lb-expiry",
+                "PolicyTypeName"=>"LBCookieStickinessPolicyType"
+              }) do
+        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].find{|e| e['PolicyName'] == 'fog-lb-expiry' }
+      end
+
+      returns({
+                "PolicyAttributeDescriptions"=>[{
+                                                  "AttributeName"=>"CookieExpirationPeriod",
+                                                  "AttributeValue"=>"0"
+                                                }],
+                "PolicyName"=>"fog-lb-no-expiry",
+                "PolicyTypeName"=>"LBCookieStickinessPolicyType"
+              }) do
+        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].find{|e| e['PolicyName'] == 'fog-lb-no-expiry' }
+      end
+
+      returns({
+                "PolicyAttributeDescriptions"=>[{
+                                                  "AttributeName"=>"PublicKey",
+                                                  "AttributeValue"=> AWS::IAM::SERVER_CERT_PUBLIC_KEY
+                                                }],
+                "PolicyName"=>"fog-policy",
+                "PolicyTypeName"=>"PublicKeyPolicyType"
+              }) do
+        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].find{|e| e['PolicyName'] == 'fog-policy' }
+      end
+    end
+
+    tests("#describe_load_balancer includes all policies") do
+      lb = Fog::AWS[:elb].describe_load_balancers("LoadBalancerNames" => [@load_balancer_id]).body["DescribeLoadBalancersResult"]["LoadBalancerDescriptions"].first
+      returns([
+               {"PolicyName"=>"fog-app-policy", "CookieName"=>"fog-app-cookie"}
+              ]) { lb["Policies"]["AppCookieStickinessPolicies"] }
+
+      returns([
+               {"PolicyName"=>"fog-lb-expiry", "CookieExpirationPeriod"=> 300}
+              ]) { lb["Policies"]["LBCookieStickinessPolicies"].select{|e| e["PolicyName"] == "fog-lb-expiry"} }
+
+      returns([
+               {"PolicyName" => "fog-lb-no-expiry"}
+              ]) { lb["Policies"]["LBCookieStickinessPolicies"].select{|e| e["PolicyName"] == "fog-lb-no-expiry"} }
+
+      returns([
+               "fog-policy"
+              ]) { lb["Policies"]["OtherPolicies"] }
+    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
+
+    proxy_policy = "EnableProxyProtocol"
+    Fog::AWS[:elb].create_load_balancer_policy(@load_balancer_id, proxy_policy, 'ProxyProtocolPolicyType', { "ProxyProtocol" => true })
+
+    tests("#set_load_balancer_policies_for_backend_server replaces policies on port").formats(AWS::ELB::Formats::BASIC) do
+      Fog::AWS[:elb].set_load_balancer_policies_for_backend_server(@load_balancer_id, 80, [proxy_policy]).body
+    end
+
+    tests("#describe_load_balancers has other policies") do
+      Fog::AWS[:elb].set_load_balancer_policies_for_backend_server(@load_balancer_id, 80, [proxy_policy]).body
+      description = Fog::AWS[:elb].describe_load_balancers("LoadBalancerNames" => [@load_balancer_id]).body["DescribeLoadBalancersResult"]["LoadBalancerDescriptions"].first
+      returns(true) { description["Policies"]["OtherPolicies"].include?(proxy_policy) }
+    end
+
+    Fog::AWS[:elb].delete_load_balancer(@load_balancer_id)
+  end
+end

data/tests/requests/emr/helper.rb

@@ -0,0 +1,168 @@
+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