fog-aws 0.7.6 → 0.8.0

data/lib/fog/aws/requests/dynamodb/delete_table.rb

@@ -11,18 +11,14 @@ module Fog
         # * response<~Excon::Response>:
         #   * body<~Hash>:
         #     * 'TableDescription'<~Hash>
-        #       * 'KeySchema'<~Hash> - schema for table
-        #         * 'HashKeyElement'<~Hash>: info for primary key
-        #           * 'AttributeName'<~String> - name of attribute
-        #           * 'AttributeType'<~String> - type of attribute, in %w{N NS S SS} for number, number set, string, string set
-        #         * 'RangeKeyElement'<~Hash>: optional, info for range key
-        #           * 'AttributeName'<~String> - name of attribute
-        #           * 'AttributeType'<~String> - type of attribute, in %w{N NS S SS} for number, number set, string, string set
         #       * 'ProvisionedThroughput'<~Hash>:
         #         * 'ReadCapacityUnits'<~Integer> - read capacity for table, in 5..10000
         #         * 'WriteCapacityUnits'<~Integer> - write capacity for table, in 5..10000
         #       * 'TableName'<~String> - name of table
         #       * 'TableStatus'<~String> - status of table
+        #
+        # See DynamoDB Documentation: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DeleteTable.html
+        #
         def delete_table(table_name)
           body = {
             'TableName' => table_name
@@ -30,7 +26,7 @@ module Fog
 
           request(
             :body       => Fog::JSON.encode(body),
-            :headers    => {'x-amz-target' => 'DynamoDB_20111205.DeleteTable'},
+            :headers    => {'x-amz-target' => 'DynamoDB_20120810.DeleteTable'},
             :idempotent => true
           )
         end

data/lib/fog/aws/requests/dynamodb/describe_table.rb

@@ -12,19 +12,18 @@ module Fog
         #   * body<~Hash>:
         #     * 'Table'<~Hash>
         #       * 'CreationDateTime'<~Float> - Unix epoch time of table creation
-        #       * 'KeySchema'<~Hash> - schema for table
-        #         * 'HashKeyElement'<~Hash>: info for primary key
-        #           * 'AttributeName'<~String> - name of attribute
-        #           * 'AttributeType'<~String> - type of attribute, in %w{N NS S SS} for number, number set, string, string set
-        #         * 'RangeKeyElement'<~Hash>: optional, info for range key
-        #           * 'AttributeName'<~String> - name of attribute
-        #           * 'AttributeType'<~String> - type of attribute, in %w{N NS S SS} for number, number set, string, string set
+        #       * 'KeySchema'<~Array> - schema for table
+        #         * 'AttributeName'<~String> - name of attribute
+        #         * 'KeyType'<~String> - type of attribute, in %w{N NS S SS} for number, number set, string, string set
         #       * 'ProvisionedThroughput'<~Hash>:
         #         * 'ReadCapacityUnits'<~Integer> - read capacity for table, in 5..10000
         #         * 'WriteCapacityUnits'<~Integer> - write capacity for table, in 5..10000
         #       * 'TableName'<~String> - name of table
         #       * 'TableSizeBytes'<~Integer> - size of table in bytes
         #       * 'TableStatus'<~String> - status of table
+        #
+        # See DynamoDB Documentation: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html
+        #
         def describe_table(table_name)
           body = {
             'TableName' => table_name
@@ -32,7 +31,7 @@ module Fog
 
           request(
             :body       => Fog::JSON.encode(body),
-            :headers    => {'x-amz-target' => 'DynamoDB_20111205.DescribeTable'},
+            :headers    => {'x-amz-target' => 'DynamoDB_20120810.DescribeTable'},
             :idempotent => true
           )
         end

data/lib/fog/aws/requests/dynamodb/get_item.rb

@@ -7,12 +7,11 @@ module Fog
         # ==== Parameters
         # * 'table_name'<~String> - name of table for item
         # * 'key'<~Hash>:
-        #   * 'HashKeyElement'<~Hash>: info for primary key
-        #     * 'AttributeType'<~String> - type of attribute
-        #     * 'AttributeName'<~String> - name of attribute
-        #   * 'RangeKeyElement'<~Hash>: optional, info for range key
-        #     * 'AttributeType'<~String> - type of attribute
-        #     * 'AttributeName'<~String> - name of attribute
+        #     {
+        #       "ForumName": {
+        #         "S": "Amazon DynamoDB"
+        #       }
+        #     }
         # * 'options'<~Hash>:
         #   * 'AttributesToGet'<~Array>: list of array names to return, defaults to returning all
         #   * 'ConsistentRead'<~Boolean>: whether to wait for updates, defaults to false
@@ -23,6 +22,9 @@ module Fog
         #     * 'ConsumedCapacityUnits'<~Float> - Capacity units used in read
         #     * 'Item':<~Hash>:
         #       * 'AttributeName'<~Hash>: in form of {"type":value}
+        #
+        # See DynamoDB Documentation: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html
+        #
         def get_item(table_name, key, options = {})
           body = {
             'Key'               => key,
@@ -31,7 +33,7 @@ module Fog
 
           request(
             :body       => Fog::JSON.encode(body),
-            :headers    => {'x-amz-target' => 'DynamoDB_20111205.GetItem'},
+            :headers    => {'x-amz-target' => 'DynamoDB_20120810.GetItem'},
             :idempotent => true
           )
         end

data/lib/fog/aws/requests/dynamodb/list_tables.rb

@@ -14,10 +14,13 @@ module Fog
         #   * body<~Hash>:
         #     * 'LastEvaluatedTableName'<~String> - last table name, for pagination
         #     * 'TableNames'<~Array> - table names
+        #
+        # See DynamoDB Documentation: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_ListTables.html
+        #
         def list_tables(options = {})
           request(
             :body       => Fog::JSON.encode(options),
-            :headers    => {'x-amz-target' => 'DynamoDB_20111205.ListTables'},
+            :headers    => {'x-amz-target' => 'DynamoDB_20120810.ListTables'},
             :idempotent => true
           )
         end

data/lib/fog/aws/requests/dynamodb/put_item.rb

@@ -7,21 +7,17 @@ module Fog
         # ==== Parameters
         # * 'table_name'<~String> - name of table for item
         # * 'item'<~Hash>: data to update, must include primary key
-        #   * 'AttributeName'<~String> - Attribute to update
-        #     * 'Value'<~Hash> - formated as {type => value}
-        #     * 'Action'<~String> - action to take if expects matches, in %w{ADD DELETE PUT}, defaults to PUT
-        # * 'options'<~Hash>:
-        #   * 'Expected'<~Hash>: data to check against
-        #     * 'AttributeName'<~String> - name of attribute
-        #     * 'Value'<~Hash> - a value to check for the value of
-        #     or
-        #     * 'Exists'<~Boolean> - set as false to only allow update if attribute doesn't exist
-        #   * 'ReturnValues'<~String> - data to return in %w{ALL_NEW ALL_OLD NONE UPDATED_NEW UPDATED_OLD}, defaults to NONE
+        #   {
+        #     "LastPostDateTime": {"S": "201303190422"}
+        #   }
         #
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
         #     varies based on ReturnValues param, see: http://docs.amazonwebservices.com/amazondynamodb/latest/developerguide/API_UpdateItem.html
+        #
+        # See DynamoDB Documentation: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html
+        #
         def put_item(table_name, item, options = {})
           body = {
             'Item'      => item,

data/lib/fog/aws/requests/dynamodb/query.rb

@@ -6,15 +6,13 @@ module Fog
         #
         # ==== Parameters
         # * 'table_name'<~String> - name of table to query
-        # * 'hash_key'<~Hash> - hash key to query
         # * options<~Hash>:
         #   * 'AttributesToGet'<~Array> - Array of attributes to get for each item, defaults to all
         #   * 'ConsistentRead'<~Boolean> - Whether to wait for consistency, defaults to false
         #   * 'Count'<~Boolean> - If true, returns only a count of such items rather than items themselves, defaults to false
         #   * 'Limit'<~Integer> - limit of total items to return
-        #   * 'RangeKeyCondition'<~Hash>: value to compare against range key
-        #     * 'AttributeValueList'<~Hash>: one or more values to compare against
-        #     * 'ComparisonOperator'<~String>: comparison operator to use with attribute value list, in %w{BETWEEN BEGINS_WITH EQ LE LT GE GT}
+        #   * 'KeyConditionExpression'<~String> - the condition elements need to match
+        #   * 'ExpressionAttributeValues'<~Hash> - values to be used in the key condition expression
         #   * 'ScanIndexForward'<~Boolean>: Whether to scan from start or end of index, defaults to start
         #   * 'ExclusiveStartKey'<~Hash>: Key to start listing from, can be taken from LastEvaluatedKey in response
         #
@@ -25,7 +23,17 @@ module Fog
         #     * 'Count'<~Integer> - number of items in response
         #     * 'Items'<~Array> - array of items returned
         #     * 'LastEvaluatedKey'<~Hash> - last key scanned, can be passed to ExclusiveStartKey for pagination
-        def query(table_name, hash_key, options = {})
+        #
+        # See DynamoDB Documentation: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html
+        #
+        def query(table_name, options = {}, hash_key_deprecated = nil)
+          if hash_key_deprecated || (options.keys.length == 1 && [:S, :N, :B].include?(options.keys.first.to_sym))
+            Fog::Logger.deprecation("The `20111205` API version is deprecated. You need to use `KeyConditionExpression` instead of `HashKey`.")
+            apiVersion = '20111205'
+            hash_key = options
+            options = hash_key_deprecated
+          end
+
           body = {
             'TableName'     => table_name,
             'HashKeyValue'  => hash_key
@@ -33,7 +41,7 @@ module Fog
 
           request(
             :body     => Fog::JSON.encode(body),
-            :headers  => {'x-amz-target' => 'DynamoDB_20111205.Query'}
+            :headers  => {'x-amz-target' => "DynamoDB_#{apiVersion || '20120810'}.Query"}
           )
         end
       end

data/lib/fog/aws/requests/dynamodb/scan.rb

@@ -11,11 +11,8 @@ module Fog
         #   * 'ConsistentRead'<~Boolean> - Whether to wait for consistency, defaults to false
         #   * 'Count'<~Boolean> - If true, returns only a count of such items rather than items themselves, defaults to false
         #   * 'Limit'<~Integer> - limit of total items to return
-        #   * 'ScanFilter'<~Hash>: value to compare against
-        #     * attribute_name<~Hash>:
-        #       * 'AttributeValueList'<~Array>: one or more values to compare against
-        #         * 'AttributeValue'<~Hash> - formated as {type => value}
-        #       * 'ComparisonOperator'<~String>: comparison operator to use with attribute value list, in %w{BETWEEN BEGINS_WITH EQ LE LT GE GT}
+        #   * 'KeyConditionExpression'<~String> - the condition elements need to match
+        #   * 'ExpressionAttributeValues'<~Hash> - values to be used in the key condition expression
         #   * 'ScanIndexForward'<~Boolean>: Whether to scan from start or end of index, defaults to start
         #   * 'ExclusiveStartKey'<~Hash>: Key to start listing from, can be taken from LastEvaluatedKey in response
         #
@@ -27,6 +24,9 @@ module Fog
         #     * 'Items'<~Array> - array of items returned
         #     * 'LastEvaluatedKey'<~Hash> - last key scanned, can be passed to ExclusiveStartKey for pagination
         #     * 'ScannedCount'<~Integer> - number of items scanned before applying filters
+        #
+        # See DynamoDB Documentation: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html
+        #
         def scan(table_name, options = {})
           body = {
             'TableName'     => table_name
@@ -34,7 +34,7 @@ module Fog
 
           request(
             :body     => Fog::JSON.encode(body),
-            :headers  => {'x-amz-target' => 'DynamoDB_20111205.Scan'},
+            :headers  => {'x-amz-target' => 'DynamoDB_20120810.Scan'},
             :idempotent => true
           )
         end

data/lib/fog/aws/requests/dynamodb/update_item.rb

@@ -2,43 +2,45 @@ module Fog
   module AWS
     class DynamoDB
       class Real
+        class DeprecatedAttributeUpdates < Exception; end
         # Update DynamoDB item
         #
         # ==== Parameters
         # * 'table_name'<~String> - name of table for item
-        # * 'key'<~Hash>:
-        #   * 'HashKeyElement'<~Hash>: info for primary key
-        #     * 'AttributeName'<~String> - name of attribute
-        #     * 'AttributeType'<~String> - type of attribute
-        #   * 'RangeKeyElement'<~Hash>: optional, info for range key
-        #     * 'AttributeName'<~String> - name of attribute
-        #     * 'AttributeType'<~String> - type of attribute
-        # * 'attribute_updates'<~Hash>:
-        #   * 'AttributeName'<~String> - Attribute to update
-        #     * 'Value'<~Hash> - formated as {type => value}
-        #     * 'Action'<~String> - action to take if expects matches, in %w{ADD DELETE PUT}, defaults to PUT
+        # * 'key'<~Hash> - list of elements to be updated and their value
+        #   {
+        #     "ForumName": {"S": "Amazon DynamoDB"},
+        #     "Subject": {"S": "Maximum number of items?"}
+        #   }
+        #
         # * 'options'<~Hash>:
-        #   * 'Expected'<~Hash>: data to check against
-        #     * 'AttributeName'<~String> - name of attribute
-        #     * 'Value'<~Hash> - a value to check for the value of
-        #     or
-        #     * 'Exists'<~Boolean> - set as false to only allow update if attribute doesn't exist
+        #   * 'KeyConditionExpression'<~String> - the condition elements need to match
+        #   * 'ExpressionAttributeValues'<~Hash> - values to be used in the key condition expression
         #   * 'ReturnValues'<~String> - data to return in %w{ALL_NEW ALL_OLD NONE UPDATED_NEW UPDATED_OLD}, defaults to NONE
         #
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
         #     varies based on ReturnValues param, see: http://docs.amazonwebservices.com/amazondynamodb/latest/developerguide/API_UpdateItem.html
-        def update_item(table_name, key, attribute_updates, options = {})
+        #
+        # See DynamoDB Documentation: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html
+        #
+        def update_item(table_name, key, options = {}, deprecated_attribute_updates = nil)
+          if deprecated_attribute_updates
+            raise DeprecatedAttributeUpdates, "The `20111205` DynamoDB API is deprecated. You need to use `ExpressionAttributeValues` instead of `AttributeUpdates`."
+            attribute_updates = options
+            options = deprecated_attribute_updates
+          end
+
           body = {
-            'AttributeUpdates'  => attribute_updates,
             'Key'               => key,
-            'TableName'         => table_name
+            'TableName'         => table_name,
+            'AttributeUpdates'  => attribute_updates,
           }.merge(options)
 
           request(
             :body     => Fog::JSON.encode(body),
-            :headers  => {'x-amz-target' => 'DynamoDB_20111205.UpdateItem'}
+            :headers  => {'x-amz-target' => 'DynamoDB_20120810.UpdateItem'}
           )
         end
       end

data/lib/fog/aws/requests/dynamodb/update_table.rb

@@ -14,18 +14,17 @@ module Fog
         # * response<~Excon::Response>:
         #   * body<~Hash>:
         #     * 'Table'<~Hash>
-        #       * 'KeySchema'<~Hash> - schema for table
-        #         * 'HashKeyElement'<~Hash>: info for primary key
+        #       * 'KeySchema'<~Array> - schema for table
         #           * 'AttributeName'<~String> - name of attribute
-        #           * 'AttributeType'<~String> - type of attribute, in %w{N NS S SS} for number, number set, string, string set
-        #         * 'RangeKeyElement'<~Hash>: optional, info for range key
-        #           * 'AttributeName'<~String> - name of attribute
-        #           * 'AttributeType'<~String> - type of attribute, in %w{N NS S SS} for number, number set, string, string set
+        #           * 'KeyType'<~String> - type of attribute, in %w{N NS S SS} for number, number set, string, string set
         #       * 'ProvisionedThroughput'<~Hash>:
         #         * 'ReadCapacityUnits'<~Integer> - read capacity for table, in 5..10000
         #         * 'WriteCapacityUnits'<~Integer> - write capacity for table, in 5..10000
         #       * 'TableName'<~String> - name of table
         #       * 'TableStatus'<~String> - status of table
+        #
+        # See DynamoDB Documentation: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html
+        #
         def update_table(table_name, provisioned_throughput)
           body = {
             'ProvisionedThroughput' => provisioned_throughput,
@@ -34,7 +33,7 @@ module Fog
 
           request(
             :body       => Fog::JSON.encode(body),
-            :headers    => {'x-amz-target' => 'DynamoDB_20111205.UpdateTable'},
+            :headers    => {'x-amz-target' => 'DynamoDB_20120810.UpdateTable'},
             :idempotent => true
           )
         end

data/lib/fog/aws/requests/elasticache/create_cache_cluster.rb

@@ -72,6 +72,7 @@ module Fog
             'CacheClusterStatus'  => 'available',
             'CacheNodes'          => create_cache_nodes(id.strip, options[:num_nodes]),
             'CacheSecurityGroups' => [],
+            'SecurityGroups'  => [],
             'CacheParameterGroup' => { 'CacheParameterGroupName' =>
                 options[:parameter_group_name] || 'default.memcached1.4' },
             'CacheSubnetGroupName' => options[:cache_subnet_group_name],

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

@@ -63,7 +63,7 @@ module Fog
                   'Arn'                      => data[:roles][role_name][:arn].strip,
                   'AssumeRolePolicyDocument' => Fog::JSON.encode(data[:roles][role_name][:assume_role_policy_document]),
                   'CreateDate'               => data[:roles][role_name][:create_date],
-                  'Path'                     => path,
+                  'Path'                     => path || "/",
                   'RoleId'                   => data[:roles][role_name][:role_id].strip,
                   'RoleName'                 => role_name,
                 },

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

@@ -34,9 +34,12 @@ module Fog
 
       class Mock
         def get_role(role_name)
-          role = self.data[:roles][role_name]
 
-          raise Fog::AWS::IAM::NotFound.new("The role with name #{role_name} cannot be found") unless role
+          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]
 
           Excon::Response.new.tap do |response|
             response.body = {

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

@@ -39,23 +39,57 @@ module Fog
 
       class Mock
         def list_roles(options={})
-          Excon::Response.new.tap do |response|
-            response.body = {
-              'Roles' => data[:roles].map do |role, data|
-                {
-                  'Arn'                      => data[:arn].strip,
-                  'AssumeRolePolicyDocument' => Fog::JSON.encode(data[:assume_role_policy_document]),
-                  'RoleId'                   => data[:role_id],
-                  'Path'                     => data[:path],
-                  'RoleName'                 => role,
-                  'CreateDate'               => data[:create_date],
-                }
-              end,
-              'RequestId' => Fog::AWS::Mock.request_id,
-              'IsTruncated' => false,
-            }
-            response.status = 200
+          limit  = options['MaxItems']
+          marker = options['Marker']
+
+          if limit
+            if limit > 1_000
+              raise Fog::AWS::IAM::Error.new(
+                "ValidationError => 1 validation error detected: Value '#{limit}' at 'limit' failed to satisfy constraint: Member must have value less than or equal to 1000"
+              )
+            elsif limit <  1
+              raise Fog::AWS::IAM::Error.new(
+                "ValidationError => 1 validation error detected: Value '#{limit}' at 'limit' failed to satisfy constraint: Member must have value greater than or equal to 1"
+              )
+            end
           end
+
+          data_set = if marker
+                       self.data[:markers][marker] || []
+                     else
+                       data[:roles].map { |role, data|
+                         {
+                           'Arn'                      => data[:arn].strip,
+                           'AssumeRolePolicyDocument' => Fog::JSON.encode(data[:assume_role_policy_document]),
+                           'RoleId'                   => data[:role_id],
+                           'Path'                     => data[:path],
+                           'RoleName'                 => role,
+                           'CreateDate'               => data[:create_date],
+                         }
+                       }
+                     end
+
+          data = data_set.slice!(0, limit || 100)
+          truncated = data_set.size > 0
+          marker = truncated && Base64.encode64("metadata/l/#{account_id}/#{UUID.uuid}")
+
+          response = Excon::Response.new
+
+          body = {
+            'Roles'       => data,
+            'IsTruncated' => truncated,
+            'RequestId'   => Fog::AWS::Mock.request_id
+          }
+
+          if marker
+            self.data[:markers][marker] = data_set
+            body.merge!('Marker' => marker)
+          end
+
+          response.body = body
+          response.status = 200
+
+          response
         end
       end
     end

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

@@ -37,71 +37,70 @@ module Fog
           end
 
           request({
-            'Action'  => 'ModifyDBInstance',
+            'Action'               => 'ModifyDBInstance',
             'DBInstanceIdentifier' => db_name,
-            'ApplyImmediately' => apply_immediately,
-            :parser   => Fog::Parsers::AWS::RDS::ModifyDBInstance.new,
+            'ApplyImmediately'     => apply_immediately,
+            :parser                => Fog::Parsers::AWS::RDS::ModifyDBInstance.new
           }.merge(options))
         end
       end
 
       class Mock
         def modify_db_instance(db_name, apply_immediately, _options={})
-          options = _options
+          options = _options.dup
           response = Excon::Response.new
-          if server = self.data[:servers][db_name]
-            if server["DBInstanceStatus"] != "available"
-              raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not available for modification")
-            else
-              self.data[:modify_time] = Time.now
-              # TODO verify the params options
-              # if apply_immediately is false, all the options go to pending_modified_values and then apply and clear after either
-              # a reboot or the maintainance window
-              #if apply_immediately
-              #  modified_server = server.merge(options)
-              #else
-              #  modified_server = server["PendingModifiedValues"].merge!(options) # it appends
-              #end
-
-              db_security_group_names = Array(options.delete("DBSecurityGroups"))
-
-              rds_security_groups = self.data[:security_groups].values
-
-              db_security_groups = db_security_group_names.map do |r, group_name|
-                unless rds_security_groups.find { |sg| sg["DBSecurityGroupName"] == group_name }
-                  raise Fog::AWS::RDS::Error.new("InvalidParameterValue => Invalid security group , groupId= , groupName=#{group_name}")
-                end
-                r << {"Status" => "active", "DBSecurityGroupName" => group_name }
-              end
-
-              ec2_security_groups = Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:security_groups].values
-
-              vpc_security_groups = Array(options.delete("VpcSecurityGroups")).map do |group_id|
-                unless ec2_security_groups.find { |sg| sg["groupId"] == group_id }
-                  raise Fog::AWS::RDS::Error.new("InvalidParameterValue => Invalid security group , groupId=#{group_id} , groupName=")
-                end
-
-                {"Status" => "active", "VpcSecurityGroupId" => group_id }
-              end
-
-              options.merge!(
-                "DBSecurityGroups"  => db_security_groups,
-                "VpcSecurityGroups" => vpc_security_groups
-              )
-
-              self.data[:servers][db_name]["PendingModifiedValues"].merge!(options) # it appends
-              self.data[:servers][db_name]["DBInstanceStatus"] = "modifying"
-              response.status = 200
-              response.body = {
-                "ResponseMetadata"       => { "RequestId"  => Fog::AWS::Mock.request_id },
-                "ModifyDBInstanceResult" => { "DBInstance" => self.data[:servers][db_name] }
-              }
-              response
 
-            end
-          else
+          server = self.data[:servers][db_name]
+
+          if server.nil?
             raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not found")
           end
+
+          if server["DBInstanceStatus"] != "available"
+            raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not available for modification")
+          end
+
+          db_security_group_names = Array(options.delete("DBSecurityGroups"))
+
+          rds_security_groups = self.data[:security_groups].values
+
+          db_security_groups = db_security_group_names.map do |r, group_name|
+            unless rds_security_groups.find { |sg| sg["DBSecurityGroupName"] == group_name }
+              raise Fog::AWS::RDS::Error.new("InvalidParameterValue => Invalid security group , groupId= , groupName=#{group_name}")
+            end
+            r << {"Status" => "active", "DBSecurityGroupName" => group_name }
+          end
+
+          ec2_security_groups = Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:security_groups].values
+
+          vpc_security_groups = Array(options.delete("VpcSecurityGroups")).map do |group_id|
+            unless ec2_security_groups.find { |sg| sg["groupId"] == group_id }
+              raise Fog::AWS::RDS::Error.new("InvalidParameterValue => Invalid security group , groupId=#{group_id} , groupName=")
+            end
+
+            {"Status" => "active", "VpcSecurityGroupId" => group_id }
+          end
+
+          options.merge!(
+            "DBSecurityGroups"  => db_security_groups,
+            "VpcSecurityGroups" => vpc_security_groups
+          )
+
+          if options["NewDBInstanceIdentifier"]
+            options["DBInstanceIdentifier"] = options.delete("NewDBInstanceIdentifier")
+          end
+
+          self.data[:modify_time] = Time.now
+          server["PendingModifiedValues"].merge!(options)
+          server["DBInstanceStatus"] = "modifying"
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"       => { "RequestId"  => Fog::AWS::Mock.request_id },
+            "ModifyDBInstanceResult" => { "DBInstance" => server }
+          }
+
+          response
         end
       end
     end