fog 1.1.2 → 1.2.0

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

@@ -34,8 +34,7 @@ module Fog
           response = Excon::Response.new
           
           unless skip_snapshot
-            # I don't know how to mock snapshot_identifier
-            Fog::Logger.warning("snapshot_identifier is not mocked [light_black](#{caller.first})[/]")
+            create_db_snapshot(identifier, snapshot_identifier)
           end
           
           if server_set = self.data[:servers].delete(identifier)

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

@@ -27,7 +27,17 @@ module Fog
       class Mock
 
         def delete_db_parameter_group(group_name)
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          
+          if self.data[:parameter_groups].delete(group_name)
+            response.status = 200
+            response.body = {
+              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            }
+            response
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBParameterGroup not found: #{group_name}")
+          end
         end
 
       end

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

@@ -25,7 +25,17 @@ module Fog
       class Mock
 
         def delete_db_security_group(name, description = name)
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          
+          if self.data[:security_groups].delete(name)
+            response.status = 200
+            response.body = {
+              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            }
+            response
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
+          end
         end
 
       end

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

@@ -12,11 +12,11 @@ module Fog
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
-        def delete_db_snapshot(group_name)
+        def delete_db_snapshot(name)
           
           request({
             'Action'  => 'DeleteDBSnapshot',
-            'DBSnapshotIdentifier' => group_name,
+            'DBSnapshotIdentifier' => name,
             
             :parser   => Fog::Parsers::AWS::RDS::DeleteDBSnapshot.new
           })
@@ -26,8 +26,19 @@ module Fog
 
       class Mock
 
-        def delete_db_snapshot(group_name)
-          Fog::Mock.not_implemented
+        def delete_db_snapshot(name)
+          # TODO: raise error if snapshot isn't 'available'
+          response = Excon::Response.new
+          snapshot_data = self.data[:snapshots].delete(name)
+
+          raise Fog::AWS::RDS::NotFound.new("DBSnapshtoNotFound => #{name} not found") unless snapshot_data
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"=> { "RequestId"=> Fog::AWS::Mock.request_id },
+            "DeleteDBSnapshotResult"=> {"DBSnapshot"=> snapshot_data}
+          }
+          response
         end
 
       end

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

@@ -21,7 +21,7 @@ module Fog
           if opts[:max_records]
             params['MaxRecords'] = opts[:max_records]
           end
-          
+
           request({
             'Action'  => 'DescribeDBInstances',
             :parser   => Fog::Parsers::AWS::RDS::DescribeDBInstances.new
@@ -35,7 +35,7 @@ module Fog
         def describe_db_instances(identifier=nil, opts={})
           response = Excon::Response.new
           server_set = []
-          if identifier   
+          if identifier
             if server = self.data[:servers][identifier]
               server_set << server
             else
@@ -44,28 +44,44 @@ module Fog
           else
             server_set = self.data[:servers].values
           end
-          
+
           server_set.each do |server|
              case server["DBInstanceStatus"]
              when "creating"
-                 if Time.now - server['created_at'] >= Fog::Mock.delay * 2
+                 if Time.now - server['InstanceCreateTime'] >= Fog::Mock.delay * 2
                    region = "us-east-1"
                    server["DBInstanceStatus"] = "available"
-                   server["availability_zone"] = region + 'a'
+                   server["AvailabilityZone"] = region + 'a'
                    server["Endpoint"] = {"Port"=>3306, 
                                          "Address"=> Fog::AWS::Mock.rds_address(server["DBInstanceIdentifier"],region) }
                    server["PendingModifiedValues"] = {}
                  end
-              when "rebooting"
+              when "rebooting" # I don't know how to show rebooting just once before it changes to available
                 # it applies pending modified values
+                if server["PendingModifiedValues"]
+                  server.merge!(server["PendingModifiedValues"])
+                  server["PendingModifiedValues"] = {}
+                  self.data[:tmp] ||= Time.now + Fog::Mock.delay * 2
+                  if self.data[:tmp] <= Time.now
+                    server["DBInstanceStatus"] = 'available'
+                    self.data.delete(:tmp)
+                  end
+                end
+              when "modifying"
+                # TODO there are some fields that only applied after rebooting
                 if server["PendingModifiedValues"]
                   server.merge!(server["PendingModifiedValues"])
                   server["PendingModifiedValues"] = {}
                   server["DBInstanceStatus"] = 'available'
                 end
-             end 
+              when "available" # I'm not sure if amazon does this
+                if server["PendingModifiedValues"]
+                  server["DBInstanceStatus"] = 'modifying'
+                end
+
+             end
           end
-          
+
           response.status = 200
           response.body = {
             "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
@@ -73,7 +89,7 @@ module Fog
           }
           response
         end
-        
+
 
       end
     end

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

@@ -36,7 +36,25 @@ module Fog
       class Mock
 
         def describe_db_parameter_groups(name=nil, opts={})
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          parameter_set = []
+          if name
+            if server = self.data[:parameter_groups][name]
+              parameter_set << server
+            else
+              raise Fog::AWS::RDS::NotFound.new("DBInstance #{name} not found")
+            end
+          else
+            parameter_set = self.data[:parameter_groups].values
+          end
+          
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "DescribeDBParameterGroupsResult" => { "DBParameterGroups" => parameter_set }
+          }
+          response
         end
 
       end

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

@@ -39,7 +39,6 @@ module Fog
         def describe_db_parameters(name, opts={})
           Fog::Mock.not_implemented
         end
-
       end
     end
   end

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

@@ -5,7 +5,7 @@ module Fog
 
         require 'fog/aws/parsers/rds/describe_db_security_groups'
 
-        # Describe all or specified db snapshots
+        # Describe all or specified db security groups
         # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/index.html?API_DescribeDBSecurityGroups.html
         # ==== Parameters
         # * DBSecurityGroupName <~String> - The name of the DB Security Group to return details for.
@@ -28,8 +28,54 @@ module Fog
 
       class Mock
 
-        def describe_db_security_group(opts={})
-          Fog::Mock.not_implemented
+        def describe_db_security_groups(opts={})
+          response = Excon::Response.new
+          sec_group_set = []
+          if opts.is_a?(String)
+            sec_group_name = opts
+            if sec_group = self.data[:security_groups][sec_group_name]
+              sec_group_set << sec_group
+            else
+              raise Fog::AWS::RDS::NotFound.new("Security Group #{sec_group_name} not found")
+            end
+          else
+            sec_group_set = self.data[:security_groups].values
+          end
+
+          # TODO: refactor to not delete items that we're iterating over. Causes
+          # model tests to fail (currently pending)
+          sec_group_set.each do |sec_group|
+            sec_group["IPRanges"].each do |iprange|
+              if iprange["Status"] == "authorizing" || iprange["Status"] == "revoking"
+                iprange[:tmp] ||= Time.now + Fog::Mock.delay * 2
+                if iprange[:tmp] <= Time.now
+                  iprange["Status"] = "authorized" if iprange["Status"] == "authorizing"
+                  iprange.delete(:tmp)
+                  sec_group["IPRanges"].delete(iprange) if iprange["Status"] == "revoking"
+                end
+              end
+            end
+
+            # TODO: refactor to not delete items that we're iterating over. Causes
+            # model tests to fail (currently pending)
+            sec_group["EC2SecurityGroups"].each do |ec2_secg|
+              if ec2_secg["Status"] == "authorizing" || iprange["Status"] == "revoking"
+                ec2_secg[:tmp] ||= Time.now + Fog::Mock.delay * 2
+                if ec2_secg[:tmp] <= Time.now
+                  ec2_secg["Status"] = "authorized" if ec2_secg["Status"] == "authorizing"
+                  ec2_secg.delete(:tmp)
+                  sec_group["EC2SecurityGroups"].delete(ec2_secg) if ec2_secg["Status"] == "revoking"
+                end
+              end
+            end
+          end
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "DescribeDBSecurityGroupsResult" => { "DBSecurityGroups" => sec_group_set }
+          }
+          response
         end
 
       end

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

@@ -33,7 +33,34 @@ module Fog
       class Mock
 
         def describe_db_snapshots(opts={})
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          snapshots = self.data[:snapshots].values
+          if opts[:identifier]
+            snapshots = snapshots.select{|snapshot| snapshot['DBInstanceIdentifier'] == opts[:identifier]}
+          end
+
+          if opts[:snapshot_id]
+            snapshots = snapshots.select{|snapshot| snapshot['DBSnapshotIdentifier'] == opts[:snapshot_id]}
+            raise Fog::AWS::RDS::NotFound.new("DBSnapshot #{opts[:snapshot_id]} not found") if snapshots.empty?
+          end
+
+          snapshots.each do |snapshot|
+            case snapshot['Status']
+            when 'creating'
+              if Time.now - snapshot['SnapshotCreateTime'] > Fog::Mock.delay
+                snapshot['Status'] = 'available'
+              end
+            end
+          end
+
+          # Build response
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "DescribeDBSnapshotsResult" => { "DBSnapshots" => snapshots }
+          }
+          response
+
         end
 
       end

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

@@ -46,22 +46,24 @@ module Fog
 
         def modify_db_instance(db_name, apply_immediately, options={})
           response = Excon::Response.new
-          if server = self.data[:servers][db_name]
-            if server["DBInstanceStatus"] != "available"
+          if self.data[:servers][db_name]
+            if self.data[:servers][db_name]["DBInstanceStatus"] != "available"
               raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not available for modification")
             else
               # 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
+              #if apply_immediately
+              #  modified_server = server.merge(options)
+              #else
+              #  modified_server = server["PendingModifiedValues"].merge!(options) # it appends
+              #end
+              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" => modified_server }
+                "ModifyDBInstanceResult" => { "DBInstance" => self.data[:servers][db_name] }
               }
               response
               

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

@@ -26,21 +26,21 @@ module Fog
 
         def reboot_db_instance(instance_identifier)
           response = Excon::Response.new
-          if server = self.data[:servers][instance_identifier]
-            if server["DBInstanceStatus"] != "available"
-              raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not available for rebooting")
+          if self.data[:servers][instance_identifier]
+            if self.data[:servers][instance_identifier]["DBInstanceStatus"] != "available"
+              raise Fog::AWS::RDS::NotFound.new("DBInstance #{instance_identifier} not available for rebooting")
             else
-              server["DBInstanceStatus"] = 'rebooting'
+              self.data[:servers][instance_identifier]["DBInstanceStatus"] = 'rebooting'
               response.status = 200
               response.body = {
                 "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
-                "RebootDBInstanceResult" => { "DBInstance" => server }
+                "RebootDBInstanceResult" => { "DBInstance" => self.data[:servers][instance_identifier] }
               }
               response
               
             end
           else
-            raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not found")
+            raise Fog::AWS::RDS::NotFound.new("DBInstance #{instance_identifier} not found")
           end
         end
 

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

@@ -33,7 +33,33 @@ module Fog
       class Mock
 
         def revoke_db_security_group_ingress(name, opts = {})
-          Fog::Mock.not_implemented
+          unless opts.key?('CIDRIP') || (opts.key?('EC2SecurityGroupName') && opts.key?('EC2SecurityGroupOwnerId'))
+            raise ArgumentError, 'Must specify CIDRIP, or both EC2SecurityGroupName and EC2SecurityGroupOwnerId'
+          end
+          
+          response = Excon::Response.new
+          
+          if sec_group = self.data[:security_groups][name]
+            if opts.key?('CIDRIP')
+              sec_group['IPRanges'].each do |iprange|
+                iprange['Status']= 'revoking' if iprange['CIDRIP'] == opts['CIDRIP']
+              end
+            else
+              sec_group['EC2SecurityGroups'].each do |ec2_secg|
+                ec2_secg['Status']= 'revoking' if ec2_secg['EC2SecurityGroupName'] == opts['EC2SecurityGroupName']
+              end
+            end
+            response.status = 200
+            response.body = {
+              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+              'RevokeDBSecurityGroupIngressResult' => {          
+                'DBSecurityGroup' => sec_group
+              }
+            }
+            response
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
+          end
         end
 
       end

data/lib/fog/aws/requests/sns/confirm_subscription.rb

@@ -21,7 +21,7 @@ module Fog
           request({
             'Action'    => 'ConfirmSubscription',
             'Token'     => token,
-            'TopicArn'  => arn,
+            'TopicArn'  => arn.strip,
             :parser     => Fog::Parsers::AWS::SNS::ConfirmSubscription.new
           }.merge!(options))
         end

data/lib/fog/aws/requests/sns/delete_topic.rb

@@ -17,7 +17,7 @@ module Fog
         def delete_topic(arn)
           request({
             'Action'    => 'DeleteTopic',
-            'TopicArn'  => arn,
+            'TopicArn'  => arn.strip,
             :parser     => Fog::Parsers::AWS::SNS::DeleteTopic.new
           })
         end

data/lib/fog/aws/requests/sns/get_topic_attributes.rb

@@ -17,7 +17,7 @@ module Fog
         def get_topic_attributes(arn)
           request({
             'Action'    => 'GetTopicAttributes',
-            'TopicArn'  => arn,
+            'TopicArn'  => arn.strip,
             :parser     => Fog::Parsers::AWS::SNS::GetTopicAttributes.new
           })
         end

data/lib/fog/aws/requests/sns/list_subscriptions_by_topic.rb

@@ -19,7 +19,7 @@ module Fog
         def list_subscriptions_by_topic(arn, options = {})
           request({
             'Action'    => 'ListSubscriptionsByTopic',
-            'TopicArn'  => arn,
+            'TopicArn'  => arn.strip,
             :parser     => Fog::Parsers::AWS::SNS::ListSubscriptions.new
           }.merge!(options))
         end

data/lib/fog/aws/requests/sns/publish.rb

@@ -22,7 +22,7 @@ module Fog
           request({
             'Action'    => 'Publish',
             'Message'   => message,
-            'TopicArn'  => arn,
+            'TopicArn'  => arn.strip,
             :parser     => Fog::Parsers::AWS::SNS::Publish.new
           }.merge!(options))
         end