fog-aws 0.11.0 → 3.18.0

data/lib/fog/aws/requests/iam/attach_group_policy.rb

@@ -46,6 +46,7 @@ module Fog
 
           group = self.data[:groups][group_name]
           group[:attached_policies] << policy_arn
+          managed_policy["AttachmentCount"] += 1
 
           Excon::Response.new.tap { |response|
             response.status = 200

data/lib/fog/aws/requests/iam/attach_role_policy.rb

@@ -20,13 +20,39 @@ module Fog
         #
         def attach_role_policy(role_name, policy_arn)
           request(
-            'Action'          => 'AttachRolePolicy',
-            'RoleName'       => role_name,
-            'PolicyArn'      => policy_arn,
-            :parser           => Fog::Parsers::AWS::IAM::Basic.new
+            'Action'    => 'AttachRolePolicy',
+            'RoleName'  => role_name,
+            'PolicyArn' => policy_arn,
+            :parser     => Fog::Parsers::AWS::IAM::Basic.new
           )
         end
       end
+
+      class Mock
+        def attach_role_policy(role_name, policy_arn)
+          response = Excon::Response.new
+          if policy_arn.nil?
+            raise Fog::AWS::IAM::ValidationError, "1 validation error detected: Value null at 'policyArn' failed to satisfy constraint: Member must not be null"
+          end
+
+          managed_policy = self.data[:managed_policies][policy_arn]
+
+          unless managed_policy
+            raise Fog::AWS::IAM::NotFound, "Policy #{policy_arn} does not exist."
+          end
+
+          unless self.data[:roles][role_name]
+            raise Fog::AWS::IAM::NotFound.new("The role with name #{role_name} cannot be found.")
+          end
+
+          role = self.data[:roles][role_name]
+          role[:attached_policies] ||= []
+          role[:attached_policies] << managed_policy['Arn']
+          managed_policy['AttachmentCount'] += 1
+          response.body = {"RequestId" => Fog::AWS::Mock.request_id}
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/attach_user_policy.rb

@@ -46,6 +46,7 @@ module Fog
 
           user = self.data[:users][user_name]
           user[:attached_policies] << policy_arn
+          managed_policy['AttachmentCount'] += 1
 
           Excon::Response.new.tap { |response|
             response.status = 200

data/lib/fog/aws/requests/iam/create_instance_profile.rb

@@ -40,6 +40,26 @@ module Fog
           }.merge!(options))
         end
       end
+
+      class Mock
+        def create_instance_profile(instance_profile_name, path='/', options={})
+          response = Excon::Response.new
+
+          profile = {
+            "Arn"                 => "arn:aws:iam::#{Fog::AWS::Mock.owner_id}:instance-profile#{path}#{instance_profile_name}",
+            "CreateDate"          => Time.now.utc,
+            "InstanceProfileId"   => Fog::Mock.random_hex(21),
+            "InstanceProfileName" => instance_profile_name,
+            "Path"                => path,
+            "Roles"               => [],
+          }
+
+          self.data[:instance_profiles][instance_profile_name] = profile
+
+          response.body = {"InstanceProfile" => profile, "RequestId" => Fog::AWS::Mock.request_id}
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/create_policy.rb

@@ -35,13 +35,37 @@ module Fog
             'PolicyName'      => policy_name,
             'PolicyDocument'  => Fog::JSON.encode(policy_document),
             'Path'            => path,
-            'Description'     => description,  
+            'Description'     => description,
             :parser           => Fog::Parsers::AWS::IAM::SinglePolicy.new
           }.reject {|_, value| value.nil?})
         end
       end
 
-      
+      class Mock
+        def create_policy(policy_name, policy_document, path="/", description=nil)
+          response = Excon::Response.new
+
+          arn = "arn:aws:iam:#{Fog::AWS::Mock.owner_id}:policy/#{policy_name}"
+
+          policy = {
+            "Arn"              => arn,
+            "AttachmentCount"  => 0,
+            "CreateDate"       => Time.now.utc,
+            "DefaultVersionId" => "v1",
+            "Description"      => description,
+            "IsAttachable"     => true,
+            "Path"             => path,
+            "PolicyId"         => Fog::Mock.random_hex(21),
+            "PolicyName"       => policy_name,
+            "UpdateDate"       => Time.now.utc,
+          }
+
+          self.data[:managed_policies][arn] = policy
+
+          response.body = {"RequestId" => Fog::AWS::Mock.request_id, "Policy" => policy}
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/delete_instance_profile.rb

@@ -25,6 +25,21 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def delete_instance_profile(instance_profile_name)
+          response = Excon::Response.new
+
+          unless profile = self.data[:instance_profiles][instance_profile_name]
+            raise Fog::AWS::IAM::NotFound.new("Instance Profile #{instance_profile_name} cannot be found.")
+          end
+
+          self.data[:instance_profiles].delete(instance_profile_name)
+
+          response.body = {"RequestId" => Fog::AWS::Mock.request_id}
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/delete_policy.rb

@@ -25,6 +25,21 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def delete_policy(policy_arn)
+          response = Excon::Response.new
+          policy = self.data[:managed_policies][policy_arn]
+
+          if policy.nil?
+            raise Fog::AWS::IAM::NotFound.new("Policy #{policy_arn} does not exist or is not attachable.")
+          end
+
+          self.data[:managed_policies].delete(policy_arn)
+          response.body = {"RequestId" => Fog::AWS::Mock.request_id}
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/detach_group_policy.rb

@@ -46,6 +46,7 @@ module Fog
 
           group = self.data[:groups][group_name]
           group[:attached_policies].delete(policy_arn)
+          managed_policy["AttachmentCount"] -= 1
 
           Excon::Response.new.tap { |response|
             response.status = 200

data/lib/fog/aws/requests/iam/detach_role_policy.rb

@@ -27,6 +27,33 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def detach_role_policy(role_name, policy_arn)
+          response = Excon::Response.new
+
+          if policy_arn.nil?
+            raise Fog::AWS::IAM::ValidationError, "1 validation error detected: Value null at 'policyArn' failed to satisfy constraint: Member must not be null"
+          end
+
+          managed_policy = self.data[:managed_policies][policy_arn]
+
+          unless managed_policy
+            raise Fog::AWS::IAM::NotFound, "Policy #{policy_arn} does not exist."
+          end
+
+          unless self.data[:roles].key?(role_name)
+            raise Fog::AWS::IAM::NotFound.new("The role with name #{role_name} cannot be found.")
+          end
+
+          role = self.data[:roles][role_name]
+          role[:attached_policies].delete(policy_arn)
+          managed_policy["AttachmentCount"] -= 1
+
+          response.body = {"RequestId" => Fog::AWS::Mock.request_id}
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/detach_user_policy.rb

@@ -46,6 +46,7 @@ module Fog
 
           user = self.data[:users][user_name]
           user[:attached_policies].delete(policy_arn)
+          managed_policy["AttachmentCount"] -= 1
 
           Excon::Response.new.tap { |response|
             response.status = 200

data/lib/fog/aws/requests/iam/get_instance_profile.rb

@@ -35,6 +35,23 @@ module Fog
           })
         end
       end
+
+      class Mock
+        def get_instance_profile(instance_profile_name)
+          response = Excon::Response.new
+
+          instance_profile = self.data[:instance_profiles][instance_profile_name]
+          unless instance_profile
+            raise Fog::AWS::IAM::NotFound.new("Instance Profile #{instance_profile_name} cannot be found.")
+          end
+
+          instance_profile = instance_profile.dup
+          instance_profile["Roles"].map! { |r| self.data[:roles][r] }
+
+          response.body = {"InstanceProfile" => instance_profile, "RequestId" => Fog::AWS::Mock.request_id}
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/list_attached_user_policies.rb

@@ -70,7 +70,8 @@ module Fog
           body = {
             'Policies'    => data,
             'IsTruncated' => truncated,
-            'RequestId'   => Fog::AWS::Mock.request_id
+            'RequestId'   => Fog::AWS::Mock.request_id,
+            'Marker'      => nil
           }
 
           if marker

data/lib/fog/aws/requests/iam/list_instance_profiles.rb

@@ -43,6 +43,15 @@ module Fog
           }.merge!(options))
         end
       end
+
+      class Mock
+        def list_instance_profiles(options={})
+          response = Excon::Response.new
+          profiles = self.data[:instance_profiles].values
+          response.body = { "InstanceProfiles" => profiles, "IsTruncated" => false, "RequestId" => Fog::AWS::Mock.request_id }
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/list_instance_profiles_for_role.rb

@@ -44,6 +44,16 @@ module Fog
           }.merge!(options))
         end
       end
+
+      class Mock
+        def list_instance_profiles_for_role(role_name, options={})
+          response = Excon::Response.new
+
+          profiles = self.data[:instance_profiles].values.select { |p| p["Roles"].include?(role_name) }
+          response.body = { "InstanceProfiles" => profiles, "IsTruncated" => false, "RequestId" => Fog::AWS::Mock.request_id }
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/list_policies.rb

@@ -64,6 +64,10 @@ module Fog
                        self.data[:managed_policies].values
                      end
 
+          if options["PathPrefix"]
+            data_set = data_set.select { |p| p["Path"].match(/^#{options["PathPrefix"]}/) }
+          end
+
           data = data_set.slice!(0, limit || 100)
           truncated = data_set.size > 0
           marker = truncated && Base64.encode64("metadata/l/#{account_id}/#{UUID.uuid}")

data/lib/fog/aws/requests/iam/remove_role_from_instance_profile.rb

@@ -28,6 +28,25 @@ module Fog
           )
         end
       end
+
+      class Mock
+        def remove_role_from_instance_profile(role_name, instance_profile_name)
+          response = Excon::Response.new
+
+          unless profile = self.data[:instance_profiles][instance_profile_name]
+            raise Fog::AWS::IAM::NotFound.new("Instance Profile #{instance_profile_name} cannot be found.")
+          end
+
+          unless role = self.data[:roles][role_name]
+            raise Fog::AWS::IAM::NotFound.new("Role #{role_name} cannot be found.")
+          end
+
+          profile["Roles"].delete(role_name)
+
+          response.body = {"RequestId" => Fog::AWS::Mock.request_id}
+          response
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/kinesis/put_record.rb

@@ -46,8 +46,7 @@ module Fog
           data = options.delete("Data")
           partition_key = options.delete("PartitionKey")
 
-          sample_method = RUBY_VERSION == "1.8.7" ? :choice : :sample
-          shard_id = stream["Shards"].send(sample_method)["ShardId"]
+          shard_id = stream["Shards"].sample["ShardId"]
           shard = stream["Shards"].detect{ |shard| shard["ShardId"] == shard_id }
           # store the records on the shard(s)
           shard["Records"] << {

data/lib/fog/aws/requests/kinesis/put_records.rb

@@ -43,8 +43,7 @@ module Fog
           record_results = records.map { |r|
             sequence_number = next_sequence_number
 
-            sample_method = RUBY_VERSION == "1.8.7" ? :choice : :sample
-            shard_id = stream["Shards"].send(sample_method)["ShardId"]
+            shard_id = stream["Shards"].sample["ShardId"]
             shard = stream["Shards"].detect{ |shard| shard["ShardId"] == shard_id }
             # store the records on the shard(s)
             shard["Records"] << r.merge("SequenceNumber" => sequence_number)

data/lib/fog/aws/requests/lambda/invoke.rb

@@ -18,10 +18,10 @@ module Fog
           headers = {}
           if client_context = params.delete('ClientContext')
             headers['X-Amz-Client-Context'] =
-              Base64::encode64(Fog::Json.encode(client_context))
+              Base64::encode64(Fog::JSON.encode(client_context))
           end
-          if client_type = params.delete('InvocationType')
-            headers['X-Amz-Client-Type'] = client_type
+          if invocation_type = params.delete('InvocationType')
+            headers['X-Amz-Invocation-Type'] = invocation_type
           end
           if log_type = params.delete('LogType')
             headers['X-Amz-Log-Type'] = log_type
@@ -51,12 +51,12 @@ module Fog
             raise Fog::AWS::Lambda::Error, message
           end
 
-          client_context = params.delete('ClientContext')
-          client_type    = params.delete('InvocationType')
-          log_type       = params.delete('LogType')
-          payload        = params.delete('Payload')
+          client_context  = params.delete('ClientContext')
+          invocation_type = params.delete('InvocationType')
+          log_type        = params.delete('LogType')
+          payload         = params.delete('Payload')
 
-          if (client_context || client_type || log_type)
+          if (client_context || invocation_type || log_type)
             message = "invoke parameters handling are not yet mocked [light_black](#{caller.first})[/]"
             Fog::Logger.warning message
             Fog::Mock.not_implemented

data/lib/fog/aws/requests/rds/add_tags_to_resource.rb

@@ -12,28 +12,30 @@ module Fog
         #   * body<~Hash>:
         def add_tags_to_resource(rds_id, tags)
           keys    = tags.keys.sort
-          values  = keys.map {|key| tags[key]}
+          values  = keys.map { |key| tags[key] }
+          resource_name = "arn:aws:rds:#{@region}:#{owner_id}:db:#{rds_id}"
+          %w[us-gov-west-1 us-gov-east-1].include?(@region) ? resource_name.insert(7, '-us-gov') : resource_name
           request({
-              'Action'        => 'AddTagsToResource',
-              'ResourceName'  => "arn:aws:rds:#{@region}:#{owner_id}:db:#{rds_id}",
-              :parser         => Fog::Parsers::AWS::RDS::Base.new,
-            }.merge(Fog::AWS.indexed_param('Tags.member.%d.Key', keys)).
-              merge(Fog::AWS.indexed_param('Tags.member.%d.Value', values)))
+            'Action' => 'AddTagsToResource',
+            'ResourceName' => resource_name,
+            :parser => Fog::Parsers::AWS::RDS::Base.new
+          }.merge(Fog::AWS.indexed_param('Tags.member.%d.Key', keys))
+              .merge(Fog::AWS.indexed_param('Tags.member.%d.Value', values)))
         end
       end
 
       class Mock
         def add_tags_to_resource(rds_id, tags)
           response = Excon::Response.new
-          if server = self.data[:servers][rds_id]
-            self.data[:tags][rds_id].merge! tags
+          if server = data[:servers][rds_id]
+            data[:tags][rds_id].merge! tags
             response.status = 200
             response.body = {
-              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id }
+              'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
             }
             response
           else
-            raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
+            raise Fog::AWS::RDS::NotFound, "DBInstance #{rds_id} not found"
           end
         end
       end

data/lib/fog/aws/requests/rds/authorize_db_security_group_ingress.rb

@@ -15,8 +15,8 @@ module Fog
         # * response<~Excon::Response>:
         #   * body<~Hash>:
         def authorize_db_security_group_ingress(name, opts={})
-          unless opts.key?('CIDRIP') || (opts.key?('EC2SecurityGroupName') && opts.key?('EC2SecurityGroupOwnerId'))
-            raise ArgumentError, 'Must specify CIDRIP, or both EC2SecurityGroupName and EC2SecurityGroupOwnerId'
+          unless opts.key?('CIDRIP') || ((opts.key?('EC2SecurityGroupName') || opts.key?('EC2SecurityGroupId')) && opts.key?('EC2SecurityGroupOwnerId'))
+            raise ArgumentError, 'Must specify CIDRIP, or one of EC2SecurityGroupName or EC2SecurityGroupId, and EC2SecurityGroupOwnerId'
           end
 
           request({
@@ -29,8 +29,13 @@ module Fog
 
       class Mock
         def authorize_db_security_group_ingress(name, opts = {})
-          unless opts.key?('CIDRIP') || (opts.key?('EC2SecurityGroupName') && opts.key?('EC2SecurityGroupOwnerId'))
-            raise ArgumentError, 'Must specify CIDRIP, or both EC2SecurityGroupName and EC2SecurityGroupOwnerId'
+          unless opts.key?('CIDRIP') || ((opts.key?('EC2SecurityGroupName') || opts.key?('EC2SecurityGroupId')) && opts.key?('EC2SecurityGroupOwnerId'))
+            raise ArgumentError, 'Must specify CIDRIP, or one of EC2SecurityGroupName or EC2SecurityGroupId, and EC2SecurityGroupOwnerId'
+          end
+
+          if ec2_security_group_id = opts.delete("EC2SecurityGroupId")
+            ec2_security_group = (Fog::AWS::Compute::Mock.data[self.region][self.aws_access_key_id][:security_groups] || {}).values.detect { |sg| sg['groupId'] == ec2_security_group_id }
+            opts['EC2SecurityGroupName'] = ec2_security_group['groupName']
           end
 
           response = Excon::Response.new
@@ -42,7 +47,7 @@ module Fog
               end
               sec_group['IPRanges'] << opts.merge({"Status" => 'authorizing'})
             else
-              if sec_group['EC2SecurityGroups'].find{|h| h['EC2SecurityGroupName'] == opts['EC2SecurityGroupName']}
+              if sec_group['EC2SecurityGroups'].find{|h| h['EC2SecurityGroupName'] == opts['EC2SecurityGroupName'] || h['EC2SecurityGroupId'] == opts['EC2SecurityGroupId']}
                 raise Fog::AWS::RDS::AuthorizationAlreadyExists.new("AuthorizationAlreadyExists => #{opts['EC2SecurityGroupName']} is alreay defined")
               end
               sec_group['EC2SecurityGroups'] << opts.merge({"Status" => 'authorizing'})

data/lib/fog/aws/requests/rds/create_db_instance.rb

@@ -83,7 +83,7 @@ module Fog
             raise Fog::AWS::RDS::InvalidParameterCombination.new('Requesting a specific availability zone is not valid for Multi-AZ instances.')
           end
 
-          ec2 = Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id]
+          ec2 = Fog::AWS::Compute::Mock.data[@region][@aws_access_key_id]
 
           db_parameter_groups     = if pg_name = options.delete("DBParameterGroupName")
                                       group = self.data[:parameter_groups][pg_name]

data/lib/fog/aws/requests/rds/create_db_subnet_group.rb

@@ -30,16 +30,15 @@ module Fog
             raise Fog::AWS::RDS::IdentifierTaken.new("DBSubnetGroupAlreadyExists => The subnet group '#{name}' already exists")
           end
 
-          # collection = Fog::Compute::AWS.new(:aws_access_key_id => 'mock key', :aws_secret_access_key => 'mock secret')
-          collection = Fog::Compute[:aws]
-          collection.region = @region
+          # collection = Fog::AWS::Compute.new(:aws_access_key_id => 'mock key', :aws_secret_access_key => 'mock secret')
+          compute_data = Fog::AWS::Compute::Mock.data[self.region][self.aws_access_key_id]
 
           subnets = subnet_ids.map do |snid|
-            subnet = collection.subnets.get(snid)
+            subnet = compute_data[:subnets].detect { |s| s['subnetId'] == snid }
             raise Fog::AWS::RDS::NotFound.new("InvalidSubnet => The subnet '#{snid}' was not found") if subnet.nil?
             subnet
           end
-          vpc_id = subnets.first.vpc_id
+          vpc_id = subnets.first['vpcId']
 
           data = {
             'DBSubnetGroupName' => name,

data/lib/fog/aws/requests/rds/delete_db_subnet_group.rb

@@ -26,6 +26,8 @@ module Fog
             raise Fog::AWS::RDS::NotFound.new("DBSubnetGroupNotFound => The subnet group '#{name}' doesn't exists")
           end
 
+          self.data[:subnet_groups].delete(name)
+
           response.body = {
             'ResponseMetadata'=>{ 'RequestId'=> Fog::AWS::Mock.request_id },
             'return' => true,

data/lib/fog/aws/requests/rds/describe_orderable_db_instance_options.rb

@@ -4,8 +4,8 @@ module Fog
       class Real
         require 'fog/aws/parsers/rds/describe_orderable_db_instance_options'
 
-        # Describe all or specified load db instances
-        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html
+        # Describe all or specified orderable db instances options
+        # https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeOrderableDBInstanceOptions.html
         # ==== Parameters
         # * Engine <~String> - The name of the engine to retrieve DB Instance options for. Required.
         # * Options <~Hash> - Hash of options. Optional. The following keys are used:
@@ -47,11 +47,17 @@ module Fog
                                    'ReadReplicaCapable' => true,
                                    'EngineVersion' => opts[:engine_version] || '5.6.12',
                                    'AvailabilityZones' => [
-                                      {'Name' => 'us-east-1b', 'ProvisionedIopsCapable' => true},
-                                      {'Name' => 'us-east-1c', 'ProvisionedIopsCapable' => true},
-                                      {'Name' => 'us-east-1d', 'ProvisionedIopsCapable' => false},
-                                      {'Name' => 'us-east-1e', 'ProvisionedIopsCapable' => true}],
+                                      {'Name' => 'us-east-1b'},
+                                      {'Name' => 'us-east-1c'},
+                                      {'Name' => 'us-east-1d'},
+                                      {'Name' => 'us-east-1e'}],
                                    'DBInstanceClass' => size,
+                                   'SupportsStorageEncryption' => true,
+                                   'SupportsPerformanceInsights' => false,
+                                   'StorageType' => 'gp2',
+                                   'SupportsIops' => false,
+                                   'SupportsIAMDatabaseAuthentication' => false,
+                                   'SupportsEnhancedMonitoring' => true,
                                    'Vpc' => opts[:vpc].nil? ? true : opts[:vpc]}
 
             end

data/lib/fog/aws/requests/rds/list_tags_for_resource.rb

@@ -11,11 +11,14 @@ module Fog
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
+
         def list_tags_for_resource(rds_id)
+          resource_name = "arn:aws:rds:#{@region}:#{owner_id}:db:#{rds_id}"
+          %w[us-gov-west-1 us-gov-east-1].include?(@region) ? resource_name.insert(7, '-us-gov') : resource_name
           request(
-            'Action'        => 'ListTagsForResource',
-            'ResourceName'  => "arn:aws:rds:#{@region}:#{owner_id}:db:#{rds_id}",
-            :parser         => Fog::Parsers::AWS::RDS::TagListParser.new
+            'Action' => 'ListTagsForResource',
+            'ResourceName' => resource_name,
+            :parser => Fog::Parsers::AWS::RDS::TagListParser.new
           )
         end
       end
@@ -23,15 +26,15 @@ module Fog
       class Mock
         def list_tags_for_resource(rds_id)
           response = Excon::Response.new
-          if server = self.data[:servers][rds_id]
+          if server = data[:servers][rds_id]
             response.status = 200
             response.body = {
-              "ListTagsForResourceResult" =>
-                {"TagList" =>  self.data[:tags][rds_id]}
+              'ListTagsForResourceResult' =>
+                { 'TagList' => data[:tags][rds_id] }
             }
             response
           else
-            raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
+            raise Fog::AWS::RDS::NotFound, "DBInstance #{rds_id} not found"
           end
         end
       end

data/lib/fog/aws/requests/rds/modify_db_instance.rb

@@ -68,7 +68,7 @@ module Fog
               end
 
               rds_security_groups = self.data[:security_groups].values
-              ec2_security_groups = Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:security_groups].values
+              ec2_security_groups = Fog::AWS::Compute::Mock.data[@region][@aws_access_key_id][:security_groups].values
 
               db_security_group_names = Array(options.delete("DBSecurityGroups"))
               db_security_groups = db_security_group_names.inject([]) do |r, group_name|

data/lib/fog/aws/requests/rds/modify_db_subnet_group.rb

@@ -0,0 +1,27 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+        require 'fog/aws/parsers/rds/modify_db_subnet_group.rb'
+
+        # Creates a db subnet group
+        # http://docs.aws.amazon.com/AmazonRDS/2012-01-15/APIReference/API_ModifyDBSubnetGroup.html
+        # ==== Parameters
+        # * DBSubnetGroupName <~String> - The name for the DB Subnet Group. This value is stored as a lowercase string. Must contain no more than 255 alphanumeric characters or hyphens. Must not be "Default".
+        # * SubnetIds <~Array> - The EC2 Subnet IDs for the DB Subnet Group.
+        # * DBSubnetGroupDescription <~String> - The description for the DB Subnet Group
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def modify_db_subnet_group(name, subnet_ids, description = nil)
+          params = { 'Action'  => 'ModifyDBSubnetGroup',
+            'DBSubnetGroupName' => name,
+            'DBSubnetGroupDescription' => description,
+            :parser   => Fog::Parsers::AWS::RDS::ModifyDBSubnetGroup.new }
+          params.merge!(Fog::AWS.indexed_param("SubnetIds.member", Array(subnet_ids)))
+          request(params)
+        end
+      end
+    end
+  end
+end