fog-maestrodev 1.8.0.20130114204828 → 1.14.0.20130806165225

data/tests/aws/requests/compute/security_group_tests.rb

@@ -15,7 +15,7 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
         'fromPort'    => Fog::Nullable::Integer,
         'groups'      => [{ 'groupName' => Fog::Nullable::String, 'userId' => String, 'groupId' => String }],
         'ipProtocol'  => String,
-        'ipRanges'    => [],
+        'ipRanges'    => [Fog::Nullable::Hash],
         'toPort'      => Fog::Nullable::Integer,
       }],
       'ipPermissionsEgress' => [],

data/tests/aws/requests/compute/spot_instance_tests.rb

@@ -12,6 +12,7 @@ Shindo.tests('Fog::Compute[:aws] | spot instance requests', ['aws']) do
         'imageId'             => String,
         'instanceType'        => String,
         'monitoring'          => Fog::Boolean,
+        'ebsOptimized'        => Fog::Boolean,
         'subnetId'            => Fog::Nullable::String,
         'iamInstanceProfile'  => Fog::Nullable::Hash,
       },
@@ -38,13 +39,13 @@ Shindo.tests('Fog::Compute[:aws] | spot instance requests', ['aws']) do
     pending if Fog.mocking?
 
     tests("#request_spot_instances('ami-3202f25b', 't1.micro', '0.001')").formats(@spot_instance_requests_format) do
-      data = Fog::Compute[:aws].request_spot_instances('ami-3202f25b', 't1.micro', '0.001').body
+      data = Fog::Compute[:aws].request_spot_instances('ami-3202f25b', 't1.micro', '0.001',{'LaunchSpecification.EbsOptimized' => false}).body
       @spot_instance_request_id = data['spotInstanceRequestSet'].first['spotInstanceRequestId']
       data
     end
 
     tests("#describe_spot_instance_requests").formats(@spot_instance_requests_format) do
-      Fog::Compute[:aws].describe_spot_instance_requests.body
+      Fog::Compute[:aws].describe_spot_instance_requests('spot-instance-request-id' => [@spot_instance_request_id]).body
     end
 
     tests("#cancel_spot_instance_requests('#{@spot_instance_request_id}')").formats(@cancel_spot_instance_request_format) do

data/tests/aws/requests/compute/volume_tests.rb

@@ -192,9 +192,9 @@ Shindo.tests('Fog::Compute[:aws] | volume requests', ['aws']) do
       Fog::Compute[:aws].create_volume(@server.availability_zone, 10, 'VolumeType' => 'io1', 'Iops' => 99)
     end
 
-    # iops invalid value (greater than 2000)
-    tests("#create_volume('#{@server.availability_zone}', 1024, 'VolumeType' => 'io1', 'Iops' => 2001)").raises(Fog::Compute::AWS::Error) do
-      Fog::Compute[:aws].create_volume(@server.availability_zone, 1024, 'VolumeType' => 'io1', 'Iops' => 2001)
+    # iops invalid value (greater than 4000)
+    tests("#create_volume('#{@server.availability_zone}', 1024, 'VolumeType' => 'io1', 'Iops' => 4001)").raises(Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].create_volume(@server.availability_zone, 1024, 'VolumeType' => 'io1', 'Iops' => 4001)
     end
 
     @volume.destroy

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

@@ -0,0 +1,44 @@
+class AWS
+  module DataPipeline
+    module Formats
+
+      BASIC = {
+        'pipelineId' => String,
+      }
+
+      LIST_PIPELINES = {
+        "hasMoreResults" => Fog::Nullable::Boolean,
+        "marker" => Fog::Nullable::String,
+        "pipelineIdList" => [
+          {
+            "id" => String,
+            "name" => String,
+          }
+        ]
+      }
+
+      DESCRIBE_PIPELINES = {
+        "pipelineDescriptionList" => [
+          {
+            "description" => Fog::Nullable::String,
+            "name" => String,
+            "pipelineId" => String,
+            "fields" => [
+              {
+                "key" => String,
+                "refValue" => Fog::Nullable::String,
+                "stringValue" => Fog::Nullable::String,
+              }
+            ]
+          }
+        ]
+      }
+
+      PUT_PIPELINE_DEFINITION = {
+        "errored" => Fog::Boolean,
+        "validationErrors" => Fog::Nullable::Array,
+      }
+	
+    end
+  end
+end

data/tests/aws/requests/data_pipeline/pipeline_tests.rb

@@ -0,0 +1,54 @@
+Shindo.tests('AWS::DataPipeline | pipeline_tests', ['aws', 'data_pipeline']) do
+  pending if Fog.mocking?
+
+  @pipeline_id = nil
+
+  tests('success') do
+    tests("#create_pipeline").formats(AWS::DataPipeline::Formats::BASIC) do
+      unique_id = 'fog-test-pipeline-unique-id'
+      name = 'fog-test-pipeline-name'
+      description = 'Fog test pipeline'
+
+      result = Fog::AWS[:data_pipeline].create_pipeline(unique_id, name, description)
+      @pipeline_id = result['pipelineId']
+      result
+    end
+
+    tests("#list_pipelines").formats(AWS::DataPipeline::Formats::LIST_PIPELINES) do
+      Fog::AWS[:data_pipeline].list_pipelines()
+    end
+
+    tests("#describe_pipelines").formats(AWS::DataPipeline::Formats::DESCRIBE_PIPELINES) do
+      ids = [@pipeline_id]
+      Fog::AWS[:data_pipeline].describe_pipelines(ids)
+    end
+
+    tests("#put_pipeline_definition").formats(AWS::DataPipeline::Formats::PUT_PIPELINE_DEFINITION) do
+      objects = [
+        {
+          "id" => "Nightly",
+          "type" => "Schedule",
+          "startDateTime" => Time.now.strftime("%Y-%m-%dT%H:%M:%S"),
+          "period" => "24 hours",
+        },
+        {
+          "id" => "Default",
+          "role" => "role-dumps",
+          "resourceRole" => "role-dumps-inst",
+          "schedule" => { "ref" => "Nightly" },
+        },
+      ]
+
+      Fog::AWS[:data_pipeline].put_pipeline_definition(@pipeline_id, objects)
+    end
+
+    tests("#activate_pipeline") do
+      Fog::AWS[:data_pipeline].activate_pipeline(@pipeline_id)
+    end
+
+    tests("#delete_pipeline") do
+      Fog::AWS[:data_pipeline].delete_pipeline(@pipeline_id)
+    end
+
+  end
+end

data/tests/aws/requests/elasticache/describe_reserved_cache_nodes.rb

@@ -0,0 +1,17 @@
+Shindo.tests('AWS::Elasticache | describe reserved cache nodes',
+  ['aws', 'elasticache']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    tests(
+    '#describe_reserved_cache_nodes'
+    ).formats(AWS::Elasticache::Formats::RESERVED_CACHE_NODES) do
+      AWS[:elasticache].describe_reserved_cache_nodes().body['ReservedCacheNodes']
+    end
+  end
+
+  tests('failure') do
+    # TODO:
+  end
+end

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

@@ -63,6 +63,23 @@ class AWS
         'SourceType'                  => String,
       }
       EVENT_LIST = [EVENT]
+      
+      RESERVED_CACHE_CLUSTER = {
+        'CacheNodeCount'                => Integer,
+        'CacheNodeType'                 => String,
+        'Duration'                      => Integer,
+        'FixedPrice'                    => Float,
+        'OfferingType'                  => String,
+        'ProductDescription'            => String,
+        'RecurringCharges'              => Array,
+        'ReservedCacheNodeId'           => String,
+        'ReservedCacheNodesOfferingId'  => String,
+        'StartTime'                     => DateTime,
+        'State'                         => String,
+        'UsagePrice'                    => Float
+      }
+      RESERVED_CACHE_CLUSTER_LIST = [RESERVED_CACHE_CLUSTER]
+      
     end
   end
 end

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

@@ -8,6 +8,7 @@ class AWS
 
       LOAD_BALANCER = {
         "AvailabilityZones" => Array,
+        "BackendServerDescriptions" => Array,
         "CanonicalHostedZoneName" => String,
         "CanonicalHostedZoneNameID" => String,
         "CreatedTime" => Time,
@@ -25,7 +26,7 @@ class AWS
           }
         }],
         "LoadBalancerName" => String,
-        "Policies" => {"LBCookieStickinessPolicies" => Array, "AppCookieStickinessPolicies" => Array},
+        "Policies" => {"LBCookieStickinessPolicies" => Array, "AppCookieStickinessPolicies" => Array, "OtherPolicies" => Array},
         "Scheme" => String,
         "SecurityGroups" => [Fog::Nullable::String],
         "SourceSecurityGroup" => {"GroupName" => String, "OwnerAlias" => String},

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

@@ -4,7 +4,7 @@ Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
 
   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']
+    @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 = [

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

@@ -3,7 +3,11 @@ Shindo.tests('AWS::ELB | load_balancer_tests', ['aws', 'elb']) do
   @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']
+    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']

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

@@ -5,6 +5,10 @@ Shindo.tests('AWS::ELB | policy_tests', ['aws', 'elb']) 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
@@ -21,17 +25,78 @@ Shindo.tests('AWS::ELB | policy_tests', ['aws', 'elb']) do
       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
+    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"].detect{|e| e['PolicyName'] == 'fog-app-policy' }
+      end
+
+      returns({
+                "PolicyAttributeDescriptions"=>[{
+                                                  "AttributeName"=>"CookieExpirationPeriod",
+                                                  "AttributeValue"=>"300"
+                                                }],
+                "PolicyName"=>"fog-lb-expiry",
+                "PolicyTypeName"=>"LBCookieStickinessPolicyType"
+              }) do
+        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].detect{|e| e['PolicyName'] == 'fog-lb-expiry' }
+      end
+
+      returns({
+                "PolicyAttributeDescriptions"=>[{
+                                                  "AttributeName"=>"CookieExpirationPeriod",
+                                                  "AttributeValue"=>"0"
+                                                }],
+                "PolicyName"=>"fog-lb-no-expiry",
+                "PolicyTypeName"=>"LBCookieStickinessPolicyType"
+              }) do
+        body["DescribeLoadBalancerPoliciesResult"]["PolicyDescriptions"].detect{|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"].detect{|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
@@ -49,6 +114,20 @@ Shindo.tests('AWS::ELB | policy_tests', ['aws', 'elb']) do
       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/aws/requests/glacier/vault_tests.rb

@@ -32,4 +32,4 @@ Shindo.tests('AWS::Glacier | glacier vault requests', ['aws']) do
 
   Fog::AWS[:sns].delete_topic topic_arn
 
-end
+end

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

@@ -4,7 +4,7 @@ class AWS
     # A self-signed test keypair. Generated using the command:
     # openssl req -new -newkey rsa:1024 -days 3650 -nodes -x509 -keyout server-private.key -out server-public.crt
     # NB: Amazon returns an error on extraneous linebreaks
-    SERVER_CERT_PUBLIC_KEY = %{-----BEGIN CERTIFICATE-----
+    SERVER_CERT = %{-----BEGIN CERTIFICATE-----
 MIIDQzCCAqygAwIBAgIJAJaZ8wH+19AtMA0GCSqGSIb3DQEBBQUAMHUxCzAJBgNV
 BAYTAlVTMREwDwYDVQQIEwhOZXcgWW9yazERMA8GA1UEBxMITmV3IFlvcmsxHzAd
 BgNVBAoTFkZvZyBUZXN0IFNuYWtlb2lsIENlcnQxHzAdBgNVBAsTFkZvZyBUZXN0
@@ -25,6 +25,9 @@ DF3qnnPyArLFx0HLB7wQdm9xYVIqQuLO+V6GRuOd+uSX//aDLDZhwbERf35hoyto
 Jfk4gX/qwuRFNy0vjQeTzdvhB1igG/w=
 -----END CERTIFICATE-----
 }
+    # The public key for SERVER_CERT. Generated using the command:
+    # openssl x509 -inform pem -in server-public.crt -pubkey -noout > server.pubkey
+    SERVER_CERT_PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC0CR76sovjdmpWRmEaf8XaG+nGe7czhpdLKkau2b16VtSjkPctxPL5U4vaMxQUboLPr+9oL+9fSYN31VzDD4hyaeGoeI5fhnGeqk71kq5uHONBOQUMbZbBQ8PVd9Sdk+y9JJ6E5fC+GhLL5I+y2DK7syBzyymq1Wi6rPp1XXF7AQIDAQAB"
 
     SERVER_CERT_PRIVATE_KEY = %{-----BEGIN RSA PRIVATE KEY-----
 MIICXAIBAAKBgQC0CR76sovjdmpWRmEaf8XaG+nGe7czhpdLKkau2b16VtSjkPct

data/tests/aws/requests/iam/server_certificate_tests.rb

@@ -13,6 +13,9 @@ Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
     'Certificate' => @certificate_format,
     'RequestId' => String
   }
+  @update_format = {
+    'RequestId' => String
+  }
   @get_server_certificate_format = {
     'Certificate' => @certificate_format,
     'RequestId' => String
@@ -22,7 +25,7 @@ Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
   }
 
   tests('#upload_server_certificate') do
-    public_key  = AWS::IAM::SERVER_CERT_PUBLIC_KEY
+    public_key  = AWS::IAM::SERVER_CERT
     private_key = AWS::IAM::SERVER_CERT_PRIVATE_KEY
     private_key_pkcs8 = AWS::IAM::SERVER_CERT_PRIVATE_KEY_PKCS8
     private_key_mismatch = AWS::IAM::SERVER_CERT_PRIVATE_KEY_MISMATCHED
@@ -64,6 +67,35 @@ Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
     end
   end
 
+  tests('#update_server_certificate') do
+    public_key  = AWS::IAM::SERVER_CERT
+    private_key = AWS::IAM::SERVER_CERT_PRIVATE_KEY
+    key_name    = "update-key"
+
+    Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, key_name)
+
+    tests('duplicate name').raises(Fog::AWS::IAM::EntityAlreadyExists) do
+      other_key_name = "other-key-name"
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, other_key_name)
+
+      Fog::AWS::IAM.new.update_server_certificate(key_name, {'NewServerCertificateName' => other_key_name})
+    end
+
+    tests('unknown name').raises(Fog::AWS::IAM::NotFound) do
+      Fog::AWS::IAM.new.update_server_certificate("unknown-key-name", {'NewServerCertificateName' => "other-keyname"})
+    end
+
+    tests('format').formats(@update_format) do
+      Fog::AWS::IAM.new.update_server_certificate(key_name).body
+    end
+
+    tests('updates name') do
+      other_key_name = "successful-update-key-name"
+      Fog::AWS::IAM.new.update_server_certificate(key_name, {'NewServerCertificateName' => other_key_name})
+      returns(true) { Fog::AWS::IAM.new.get_server_certificate(other_key_name).body['Certificate']['ServerCertificateName'] == other_key_name }
+    end
+  end
+
   tests('#get_server_certificate').formats(@get_server_certificate_format) do
     tests('raises NotFound').raises(Fog::AWS::IAM::NotFound) do
       Fog::AWS::IAM.new.get_server_certificate("#{@key_name}fake")

data/tests/aws/requests/iam/user_tests.rb

@@ -6,10 +6,11 @@ Shindo.tests('AWS::IAM | user requests', ['aws']) do
 
     @user_format = {
       'User' => {
-        'Arn'       => String,
-        'Path'      => String,
-        'UserId'    => String,
-        'UserName'  => String
+        'Arn'        => String,
+        'Path'       => String,
+        'UserId'     => String,
+        'UserName'   => String,
+        'CreateDate' => Time
       },
       'RequestId' => String
     }
@@ -20,10 +21,11 @@ Shindo.tests('AWS::IAM | user requests', ['aws']) do
 
     @users_format = {
       'Users' => [{
-        'Arn'       => String,
-        'Path'      => String,
-        'UserId'    => String,
-        'UserName'  => String
+        'Arn'        => String,
+        'Path'       => String,
+        'UserId'     => String,
+        'UserName'   => String,
+        'CreateDate' => Time
       }],
       'IsTruncated' => Fog::Boolean,
       'RequestId'   => String