fog 1.1.0 → 1.2.0

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

@@ -8,7 +8,7 @@ Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
 
     tests("#create_load_balancer_listeners").formats(AWS::ELB::Formats::BASIC) do
       listeners = [
-        {'Protocol' => 'TCP', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => @certificate['Arn']},
+        {'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
@@ -22,7 +22,7 @@ Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
 
     tests("#create_load_balancer_listeners with non-existant SSL certificate") do
       listeners = [
-        {'Protocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => 'non-existant'},
+        {'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
@@ -30,7 +30,7 @@ Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
     tests("#create_load_balancer_listeners with invalid SSL certificate").raises(Fog::AWS::IAM::NotFound) do
       sleep 8 unless Fog.mocking?
       listeners = [
-        {'Protocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => "#{@certificate['Arn']}fake"},
+        {'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
@@ -39,7 +39,25 @@ Shindo.tests('AWS::ELB | listener_tests', ['aws', 'elb']) do
     tests("#create_load_balancer_listeners with SSL certificate").formats(AWS::ELB::Formats::BASIC) do
       sleep 8 unless Fog.mocking?
       listeners = [
-        {'Protocol' => 'HTTPS', 'LoadBalancerPort' => 443, 'InstancePort' => 443, 'SSLCertificateId' => @certificate['Arn']},
+        {'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

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

@@ -21,6 +21,19 @@ 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
+    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

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

@@ -1,8 +1,6 @@
 Shindo.tests('AWS::IAM | access key requests', ['aws']) do
 
-  unless Fog.mocking?
-    Fog::AWS[:iam].create_user('fog_access_key_tests')
-  end
+  Fog::AWS[:iam].create_user('fog_access_key_tests')
 
   tests('success') do
 
@@ -17,7 +15,6 @@ Shindo.tests('AWS::IAM | access key requests', ['aws']) do
     }
 
     tests("#create_access_key('UserName' => 'fog_access_key_tests')").formats(@access_key_format) do
-      pending if Fog.mocking?
       data = Fog::AWS[:iam].create_access_key('UserName' => 'fog_access_key_tests').body
       @access_key_id = data['AccessKey']['AccessKeyId']
       data
@@ -33,7 +30,6 @@ Shindo.tests('AWS::IAM | access key requests', ['aws']) do
     }
 
     tests("#list_access_keys('Username' => 'fog_access_key_tests')").formats(@access_keys_format) do
-      pending if Fog.mocking?
       Fog::AWS[:iam].list_access_keys('UserName' => 'fog_access_key_tests').body
     end
 
@@ -43,7 +39,6 @@ Shindo.tests('AWS::IAM | access key requests', ['aws']) do
     end
 
     tests("#delete_access_key('#{@access_key_id}', 'UserName' => 'fog_access_key_tests)").formats(AWS::IAM::Formats::BASIC) do
-      pending if Fog.mocking?
       Fog::AWS[:iam].delete_access_key(@access_key_id, 'UserName' => 'fog_access_key_tests').body
     end
 
@@ -57,4 +52,4 @@ Shindo.tests('AWS::IAM | access key requests', ['aws']) do
     Fog::AWS[:iam].delete_user('fog_access_key_tests')
   end
 
-end
+end

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

@@ -13,7 +13,6 @@ Shindo.tests('AWS::IAM | group requests', ['aws']) do
     }
 
     tests("#create_group('fog_group')").formats(@group_format) do
-      pending if Fog.mocking?
       Fog::AWS[:iam].create_group('fog_group').body
     end
 
@@ -29,12 +28,10 @@ Shindo.tests('AWS::IAM | group requests', ['aws']) do
     }
 
     tests("#list_groups").formats(@groups_format) do
-      pending if Fog.mocking?
       Fog::AWS[:iam].list_groups.body
     end
 
     tests("#delete_group('fog_group')").formats(AWS::IAM::Formats::BASIC) do
-      pending if Fog.mocking?
       Fog::AWS[:iam].delete_group('fog_group').body
     end
 
@@ -44,4 +41,4 @@ Shindo.tests('AWS::IAM | group requests', ['aws']) do
     test('failing conditions')
   end
 
-end
+end

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

@@ -41,6 +41,25 @@ c0AQtoYBTJePxiYyd8i32ypkkK83ar+sFoxKO9jYwD1IkZax2xZ0aoTdMindQPR7
 Yjs+QiLmOHcbPqX+GHcCQERsSn0RjzKmKirDntseMB59BB/cEN32+gMDVsZuCfb+
 fOy2ZavFl13afnhbh2/AjKeDhnb19x/uXjF7JCUtwpA=
 -----END RSA PRIVATE KEY-----
+}
+
+    # openssl pkcs8 -nocrypt -topk8 -in SERVER_CERT_PRIVATE_KEY.key -outform pem
+    SERVER_CERT_PRIVATE_KEY_PKCS8 = %{-----BEGIN PRIVATE KEY-----
+MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBALQJHvqyi+N2alZG
+YRp/xdob6cZ7tzOGl0sqRq7ZvXpW1KOQ9y3E8vlTi9ozFBRugs+v72gv719Jg3fV
+XMMPiHJp4ah4jl+GcZ6qTvWSrm4c40E5BQxtlsFDw9V31J2T7L0knoTl8L4aEsvk
+j7LYMruzIHPLKarVaLqs+nVdcXsBAgMBAAECgYA2ONEFvCR5ez6HgWbZbkYObH25
+86S3df+2+aKUIqv4XpJoOM7ZEAoFoW3rZ5rSlH39QwWdoWI8lo1r1+y6KsFzAh35
+GLOu4Sn7sUbOIz2YLmRwTtYpmteAYacu2qDjHm3BUsCuCnSOLtMDXyr/vi5Osjhr
+PwfmJNjifb05GUuaaQJBAOwYy4sSAYeA3ljVz1rHUNP+tRcrGeqwiuKNGSBuJOdw
+cACsUnzxzfLKRaoa9idIXAxLwNJaI/I9oAic02Vv988CQQDDNngJ+8n46UT76tM8
+f2N6YLz12fELsQUa5YmbB1p2d6/wRiC6+95x0Z0a20PtCxkqlzPmYOeA5SCFtWby
+8EQvAkAwd86hWCr0NGJw/kO5MR3Ix4tJnFGPunpok+rKm5H76Ts1CCtO9xz+cMPo
+beyGl/Y9l/eXt2WVv0zxN7C2LExFAkEAh1dzQBC2hgFMl4/GJjJ3yLfbKmSQrzdq
+v6wWjEo72NjAPUiRlrHbFnRqhN0yKd1A9HtiOz5CIuY4dxs+pf4YdwJARGxKfRGP
+MqYqKsOe2x4wHn0EH9wQ3fb6AwNWxm4J9v587LZlq8WXXdp+eFuHb8CMp4OGdvX3
+H+5eMXskJS3CkA==
+-----END PRIVATE KEY-----
 }
 
     SERVER_CERT_PRIVATE_KEY_MISMATCHED = %{-----BEGIN RSA PRIVATE KEY-----

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

@@ -24,6 +24,7 @@ Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
   tests('#upload_server_certificate') do
     public_key  = AWS::IAM::SERVER_CERT_PUBLIC_KEY
     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
 
     tests('empty public key').raises(Fog::AWS::IAM::ValidationError) do
@@ -42,6 +43,10 @@ Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
       Fog::AWS::IAM.new.upload_server_certificate(public_key, 'abcde', @key_name)
     end
 
+    tests('non-RSA private key').raises(Fog::AWS::IAM::MalformedCertificate) do
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key_pkcs8, @key_name)
+    end
+
     tests('mismatched private key').raises(Fog::AWS::IAM::KeyPairMismatch) do
       Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key_mismatch, @key_name)
     end

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

@@ -1,15 +1,12 @@
 Shindo.tests('AWS::IAM | user policy requests', ['aws']) do
 
-  unless Fog.mocking?
-    Fog::AWS[:iam].create_user('fog_user_policy_tests')
-  end
+  Fog::AWS[:iam].create_user('fog_user_policy_tests')
 
   tests('success') do
 
     @policy = {"Statement" => [{"Effect" => "Allow", "Action" => "*", "Resource" => "*"}]}
 
     tests("#put_user_policy('fog_user_policy_tests', 'fog_policy', #{@policy.inspect})").formats(AWS::IAM::Formats::BASIC) do
-      pending if Fog.mocking?
       Fog::AWS[:iam].put_user_policy('fog_user_policy_tests', 'fog_policy', @policy).body
     end
 
@@ -19,13 +16,11 @@ Shindo.tests('AWS::IAM | user policy requests', ['aws']) do
       'RequestId'   => String
     }
 
-    tests("list_user_policies('fog_user_policy_tests')").formats(@user_policies_format) do
-      pending if Fog.mocking?
+    tests("#list_user_policies('fog_user_policy_tests')").formats(@user_policies_format) do
       Fog::AWS[:iam].list_user_policies('fog_user_policy_tests').body
     end
 
     tests("#delete_user_policy('fog_user_policy_tests', 'fog_policy')").formats(AWS::IAM::Formats::BASIC) do
-      pending if Fog.mocking?
       Fog::AWS[:iam].delete_user_policy('fog_user_policy_tests', 'fog_policy').body
     end
 
@@ -35,8 +30,6 @@ Shindo.tests('AWS::IAM | user policy requests', ['aws']) do
     test('failing conditions')
   end
 
-  unless Fog.mocking?
-    Fog::AWS[:iam].delete_user('fog_user_policy_tests')
-  end
+  Fog::AWS[:iam].delete_user('fog_user_policy_tests')
 
-end
+end

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

@@ -1,8 +1,6 @@
 Shindo.tests('AWS::IAM | user requests', ['aws']) do
 
-  unless Fog.mocking?
-    Fog::AWS[:iam].create_group('fog_user_tests')
-  end
+  Fog::AWS[:iam].create_group('fog_user_tests')
 
   tests('success') do
 
@@ -17,7 +15,6 @@ Shindo.tests('AWS::IAM | user requests', ['aws']) do
     }
 
     tests("#create_user('fog_user')").formats(@user_format) do
-      pending if Fog.mocking?
       Fog::AWS[:iam].create_user('fog_user').body
     end
 
@@ -33,33 +30,43 @@ Shindo.tests('AWS::IAM | user requests', ['aws']) do
     }
 
     tests("#list_users").formats(@users_format) do
-      pending if Fog.mocking?
       Fog::AWS[:iam].list_users.body
     end
 
     tests("#add_user_to_group('fog_user_tests', 'fog_user')").formats(AWS::IAM::Formats::BASIC) do
-      pending if Fog.mocking?
       Fog::AWS[:iam].add_user_to_group('fog_user_tests', 'fog_user').body
     end
 
+    @groups_format = {
+      'GroupsForUser' => [{
+        'Arn'       => String,
+        'GroupId'   => String,
+        'GroupName' => String,
+        'Path'      => String
+      }],
+      'IsTruncated' => Fog::Boolean,
+      'RequestId'   => String
+    }
+
+    tests("#list_groups_for_user('fog_user')").formats(@groups_format) do
+      Fog::AWS[:iam].list_groups_for_user('fog_user').body
+    end
+
     tests("#remove_user_from_group('fog_user_tests', 'fog_user')").formats(AWS::IAM::Formats::BASIC) do
-      pending if Fog.mocking?
       Fog::AWS[:iam].remove_user_from_group('fog_user_tests', 'fog_user').body
     end
 
     tests("#delete_user('fog_user')").formats(AWS::IAM::Formats::BASIC) do
-      pending if Fog.mocking?
       Fog::AWS[:iam].delete_user('fog_user').body
     end
 
+
   end
 
   tests('failure') do
     test('failing conditions')
   end
 
-  unless Fog.mocking?
-    Fog::AWS[:iam].delete_group('fog_user_tests')
-  end
+  Fog::AWS[:iam].delete_group('fog_user_tests')
 
-end
+end

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

@@ -7,7 +7,7 @@ class AWS
       BASIC = {
         'ResponseMetadata' => {'RequestId' => String}
       }
-      
+
       DB_PARAMETER_GROUP = {
           'DBParameterGroupFamily' => String,
           'DBParameterGroupName'=> String,
@@ -15,24 +15,57 @@ class AWS
       }
       CREATE_DB_PARAMETER_GROUP = {
         'ResponseMetadata' => {'RequestId' => String},
-        'CreateDBParameterGroupResult' => {          
+        'CreateDBParameterGroupResult' => {
           'DBParameterGroup' => DB_PARAMETER_GROUP
         }
       }
 
+      DB_SECURITY_GROUP = {
+        'DBSecurityGroupDescription' => String,
+        'DBSecurityGroupName' => String,
+        'EC2SecurityGroups' => [Fog::Nullable::Hash],
+        'IPRanges' => [Fog::Nullable::Hash],
+        'OwnerId' => Fog::Nullable::String
+      }
+
+      CREATE_DB_SECURITY_GROUP = BASIC.merge({
+        'CreateDBSecurityGroupResult' => {
+        'DBSecurityGroup' => DB_SECURITY_GROUP
+        }
+      })
+
+      AUTHORIZE_DB_SECURITY_GROUP = BASIC.merge({
+        'AuthorizeDBSecurityGroupIngressResult' => {
+          'DBSecurityGroup' => DB_SECURITY_GROUP
+        }
+      })
+
+      REVOKE_DB_SECURITY_GROUP = BASIC.merge({
+        'RevokeDBSecurityGroupIngressResult' => {
+          'DBSecurityGroup' => DB_SECURITY_GROUP
+        }
+      })
+
+      DESCRIBE_DB_SECURITY_GROUP = BASIC.merge({
+        'DescribeDBSecurityGroupsResult' => {
+          'DBSecurityGroups' => [DB_SECURITY_GROUP]
+        }
+      })
+
       DESCRIBE_DB_PARAMETER_GROUP = {
         'ResponseMetadata' => {'RequestId' => String},
         'DescribeDBParameterGroupsResult' =>{
           'DBParameterGroups' => [DB_PARAMETER_GROUP]
         }
       }
-      
+
       MODIFY_PARAMETER_GROUP = BASIC.merge({
         'ModifyDBParameterGroupResult' => {
           'DBParameterGroupName' => String
         }
       })
-      
+
+
       DB_PARAMETER = {
         'ParameterValue' => Fog::Nullable::String,
         'DataType' => String,
@@ -41,17 +74,17 @@ class AWS
         'IsModifiable' => Fog::Boolean,
         'Description' => String,
         'ParameterName' => String,
-        'ApplyType' => String,
+        'ApplyType' => String
       }
+
       DESCRIBE_DB_PARAMETERS = BASIC.merge({
         'DescribeDBParametersResult' => {
           'Marker' => Fog::Nullable::String,
           'Parameters' => [DB_PARAMETER]
         }
-      
+
       })
-      
-      
+
       SNAPSHOT={
         'AllocatedStorage' => Integer,
         'AvailabilityZone' => String,
@@ -105,9 +138,10 @@ class AWS
         'PreferredBackupWindow'=> String,
         'PreferredMaintenanceWindow'=> String,
         'ReadReplicaDBInstanceIdentifiers'=> [String],
+        'ReadReplicaDBInstanceIdentifiers'=> [Fog::Nullable::String],
         'ReadReplicaSourceDBInstanceIdentifier'=> Fog::Nullable::String
       }
-      
+
       CREATE_DB_INSTANCE = BASIC.merge({
         'CreateDBInstanceResult' => {
           'DBInstance' => INSTANCE
@@ -132,13 +166,13 @@ class AWS
           'DBInstance' => INSTANCE
         }
       })
-      
+
       REBOOT_DB_INSTANCE = BASIC.merge({
         'RebootDBInstanceResult' => {
           'DBInstance' => INSTANCE
         }
       })
-      
+
       CREATE_READ_REPLICA = BASIC.merge({
         'CreateDBInstanceReadReplicaResult' => {
           'DBInstance' => INSTANCE

data/tests/aws/requests/rds/instance_tests.rb

@@ -10,7 +10,6 @@ Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
   @db_final_snapshot_id = "fog-final-snapshot"
 
   tests('success') do
-    pending if Fog.mocking?
 
     tests("#create_db_instance").formats(AWS::RDS::Formats::CREATE_DB_INSTANCE) do
       result = Fog::AWS[:rds].create_db_instance(@db_instance_id, 'AllocatedStorage' => 5,
@@ -71,6 +70,8 @@ Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
 
     server.reload.wait_for { state == 'available' }
 
+    pending if Fog.mocking?
+
     tests( "#create read replica").formats(AWS::RDS::Formats::CREATE_READ_REPLICA) do
       Fog::AWS[:rds].create_db_instance_read_replica(@db_replica_id, @db_instance_id).body
     end
@@ -113,8 +114,6 @@ Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
   end
 
   tests('failure') do
-    pending if Fog.mocking?
-
     tests "deleting nonexisting instance" do
       raises(Fog::AWS::RDS::NotFound) {Fog::AWS[:rds].delete_db_instance('doesnexist', 'irrelevant')}
     end

data/tests/aws/requests/rds/parameter_group_tests.rb

@@ -1,9 +1,7 @@
 Shindo.tests('AWS::RDS | parameter group requests', ['aws', 'rds']) do
   tests('success') do
-    pending if Fog.mocking?
 
     tests("#create_db_parameter_groups").formats(AWS::RDS::Formats::CREATE_DB_PARAMETER_GROUP) do
-      pending if Fog.mocking?
       body = Fog::AWS[:rds].create_db_parameter_group('fog-group', 'MySQL5.1', 'Some description').body
 
       returns( 'mysql5.1') { body['CreateDBParameterGroupResult']['DBParameterGroup']['DBParameterGroupFamily']}
@@ -16,16 +14,14 @@ Shindo.tests('AWS::RDS | parameter group requests', ['aws', 'rds']) do
     Fog::AWS[:rds].create_db_parameter_group('other-fog-group', 'MySQL5.1', 'Some description')
 
     tests("#describe_db_parameter_groups").formats(AWS::RDS::Formats::DESCRIBE_DB_PARAMETER_GROUP) do
-      pending if Fog.mocking?
 
       body = Fog::AWS[:rds].describe_db_parameter_groups().body
       
-      returns(3) {body['DescribeDBParameterGroupsResult']['DBParameterGroups'].length}      
+      returns(4) {body['DescribeDBParameterGroupsResult']['DBParameterGroups'].length}      
       body
     end
 
     tests("#describe_db_parameter_groups('fog-group)").formats(AWS::RDS::Formats::DESCRIBE_DB_PARAMETER_GROUP) do
-      pending if Fog.mocking?
 
       body = Fog::AWS[:rds].describe_db_parameter_groups('fog-group').body
       
@@ -40,7 +36,6 @@ Shindo.tests('AWS::RDS | parameter group requests', ['aws', 'rds']) do
     end
     
     tests("delete_db_parameter_group").formats(AWS::RDS::Formats::BASIC) do
-      pending if Fog.mocking?
       body = Fog::AWS[:rds].delete_db_parameter_group('fog-group').body
       
       raises(Fog::AWS::RDS::NotFound) {Fog::AWS[:rds].describe_db_parameter_groups('fog-group')}
@@ -52,7 +47,6 @@ Shindo.tests('AWS::RDS | parameter group requests', ['aws', 'rds']) do
   end
 
   tests("failures") do
-    pending if Fog.mocking?
     raises(Fog::AWS::RDS::NotFound) {Fog::AWS[:rds].describe_db_parameter_groups('doesntexist')}
     raises(Fog::AWS::RDS::NotFound) {Fog::AWS[:rds].delete_db_parameter_group('doesntexist')}
 

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

@@ -0,0 +1,101 @@
+Shindo.tests('AWS::RDS | security group requests', ['aws', 'rds']) do
+  suffix = rand(65536).to_s(16)
+
+  @sec_group_name  = "fog-sec-group-#{suffix}"
+  if Fog.mocking?
+    @owner_id = '123456780'
+  else
+    @owner_id = Fog::AWS[:rds].security_groups.get('default').owner_id
+  end
+  
+  tests('success') do
+
+    tests("#create_db_security_group").formats(AWS::RDS::Formats::CREATE_DB_SECURITY_GROUP) do
+      body = Fog::AWS[:rds].create_db_security_group(@sec_group_name, 'Some description').body
+
+      returns( @sec_group_name) { body['CreateDBSecurityGroupResult']['DBSecurityGroup']['DBSecurityGroupName']}
+      returns( 'Some description') { body['CreateDBSecurityGroupResult']['DBSecurityGroup']['DBSecurityGroupDescription']}
+      returns( []) { body['CreateDBSecurityGroupResult']['DBSecurityGroup']['EC2SecurityGroups']}
+      returns( []) { body['CreateDBSecurityGroupResult']['DBSecurityGroup']['IPRanges']}
+      
+      body
+    end
+    
+    tests("#describe_db_security_groups").formats(AWS::RDS::Formats::DESCRIBE_DB_SECURITY_GROUP) do
+      Fog::AWS[:rds].describe_db_security_groups.body
+    end
+    
+    tests("#authorize_db_security_group_ingress CIDR").formats(AWS::RDS::Formats::AUTHORIZE_DB_SECURITY_GROUP) do
+      @cidr = '0.0.0.0/0'
+      body = Fog::AWS[:rds].authorize_db_security_group_ingress(@sec_group_name,{'CIDRIP'=>@cidr}).body
+      
+      returns("authorizing") { body['AuthorizeDBSecurityGroupIngressResult']['DBSecurityGroup']['IPRanges'].detect{|h| h['CIDRIP'] == @cidr}['Status']}
+      body
+    end
+    
+    sec_group = Fog::AWS[:rds].security_groups.get(@sec_group_name)
+    sec_group.wait_for {ready?}
+    
+    tests("#authorize_db_security_group_ingress another CIDR").formats(AWS::RDS::Formats::AUTHORIZE_DB_SECURITY_GROUP) do
+      @cidr = "10.0.0.0/24"
+      body = Fog::AWS[:rds].authorize_db_security_group_ingress(@sec_group_name,{'CIDRIP'=>@cidr}).body
+      
+      returns("authorizing") { body['AuthorizeDBSecurityGroupIngressResult']['DBSecurityGroup']['IPRanges'].detect{|h| h['CIDRIP'] == @cidr}['Status']}
+      body
+    end
+    
+    sec_group = Fog::AWS[:rds].security_groups.get(@sec_group_name)
+    sec_group.wait_for {ready?}
+    
+    tests("#count CIDRIP").formats(AWS::RDS::Formats::DESCRIBE_DB_SECURITY_GROUP) do
+      body = Fog::AWS[:rds].describe_db_security_groups(@sec_group_name).body
+      returns(2) { body['DescribeDBSecurityGroupsResult']['DBSecurityGroups'][0]['IPRanges'].size }
+      body
+    end
+    
+    tests("#revoke_db_security_group_ingress CIDR").formats(AWS::RDS::Formats::REVOKE_DB_SECURITY_GROUP) do
+      @cidr = '0.0.0.0/0'
+      body = Fog::AWS[:rds].revoke_db_security_group_ingress(@sec_group_name,{'CIDRIP'=> @cidr}).body
+      returns("revoking") { body['RevokeDBSecurityGroupIngressResult']['DBSecurityGroup']['IPRanges'].detect{|h| h['CIDRIP'] == @cidr}['Status']}
+      body
+    end
+    
+    tests("#authorize_db_security_group_ingress EC2").formats(AWS::RDS::Formats::AUTHORIZE_DB_SECURITY_GROUP) do
+      @ec2_sec_group = 'default'
+      body = Fog::AWS[:rds].authorize_db_security_group_ingress(@sec_group_name,{'EC2SecurityGroupName' => @ec2_sec_group, 'EC2SecurityGroupOwnerId' => @owner_id}).body
+      
+      returns("authorizing") { body['AuthorizeDBSecurityGroupIngressResult']['DBSecurityGroup']['EC2SecurityGroups'].detect{|h| h['EC2SecurityGroupName'] == @ec2_sec_group}['Status']}
+      returns(@owner_id) { body['AuthorizeDBSecurityGroupIngressResult']['DBSecurityGroup']['EC2SecurityGroups'].detect{|h| h['EC2SecurityGroupName'] == @ec2_sec_group}['EC2SecurityGroupOwnerId']}
+      body
+    end
+    
+    tests("duplicate #authorize_db_security_group_ingress EC2").raises(Fog::AWS::RDS::AuthorizationAlreadyExists) do
+      @ec2_sec_group = 'default'
+      
+      Fog::AWS[:rds].authorize_db_security_group_ingress(@sec_group_name,{'EC2SecurityGroupName' => @ec2_sec_group, 'EC2SecurityGroupOwnerId' => @owner_id})
+    end
+    
+    sec_group = Fog::AWS[:rds].security_groups.get(@sec_group_name)
+    sec_group.wait_for {ready?}
+    
+    tests("#revoke_db_security_group_ingress EC2").formats(AWS::RDS::Formats::REVOKE_DB_SECURITY_GROUP) do
+      @ec2_sec_group = 'default'
+      
+      body = Fog::AWS[:rds].revoke_db_security_group_ingress(@sec_group_name,{'EC2SecurityGroupName' => @ec2_sec_group, 'EC2SecurityGroupOwnerId' => @owner_id}).body
+      
+      returns("revoking") { body['RevokeDBSecurityGroupIngressResult']['DBSecurityGroup']['EC2SecurityGroups'].detect{|h| h['EC2SecurityGroupName'] == @ec2_sec_group}['Status']}
+      body
+    end
+    
+    
+    #TODO, authorize ec2 security groups
+    
+    tests("#delete_db_security_group").formats(AWS::RDS::Formats::BASIC) do
+      body = Fog::AWS[:rds].delete_db_security_group(@sec_group_name).body
+      
+      raises(Fog::AWS::RDS::NotFound) {Fog::AWS[:rds].describe_db_security_groups(@sec_group_name)}
+
+      body
+    end
+  end
+end

data/tests/aws/requests/storage/{hash_to_acl_tests.rb → acl_utils_tests.rb}

@@ -1,6 +1,6 @@
-require 'fog/aws/requests/storage/hash_to_acl'
+require 'fog/aws/requests/storage/acl_utils'
 
-Shindo.tests('Fog::Storage::AWS | converting a hash to an ACL', [:aws]) do
+Shindo.tests('Fog::Storage::AWS | ACL utils', [:aws]) do
   tests(".hash_to_acl") do
     tests(".hash_to_acl({}) at xpath //AccessControlPolicy").returns("", "has an empty AccessControlPolicy") do
       xml = Fog::Storage::AWS.hash_to_acl({})
@@ -170,4 +170,40 @@ Shindo.tests('Fog::Storage::AWS | converting a hash to an ACL', [:aws]) do
       Nokogiri::XML(xml).xpath("//AccessControlPolicy/AccessControlList/Grant/Grantee/URI").first.content
     end
   end
+
+  tests(".acl_to_hash") do
+    acl_xml = <<-XML
+<AccessControlPolicy>
+  <Owner>
+    <ID>2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0</ID>
+    <DisplayName>me</DisplayName>
+  </Owner>
+  <AccessControlList>
+    <Grant>
+      <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
+        <ID>2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0</ID>
+        <DisplayName>me</DisplayName>
+      </Grantee>
+      <Permission>FULL_CONTROL</Permission>
+    </Grant>
+  </AccessControlList>
+</AccessControlPolicy>
+XML
+
+    tests(".acl_to_hash(#{acl_xml.inspect})").returns({
+      "Owner" => {
+        "DisplayName" => "me",
+        "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0"
+      },
+      "AccessControlList" => [{
+        "Grantee" => {
+          "DisplayName" => "me",
+          "ID" => "2744ccd10c7533bd736ad890f9dd5cab2adb27b07d500b9493f29cdc420cb2e0"
+        },
+        "Permission" => "FULL_CONTROL"
+      }]
+    }, 'returns hash of ACL XML') do
+      Fog::Storage::AWS.acl_to_hash(acl_xml)
+    end
+  end
 end