fog 1.1.0 → 1.2.0

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

@@ -29,6 +29,22 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def delete_user_policy(user_name, policy_name)
+          if data[:users].has_key?(user_name) && data[:users][user_name][:policies].has_key?(policy_name)
+            data[:users][user_name][:policies].delete policy_name
+            Excon::Response.new.tap do |response|
+              response.body = { 'RequestId' => Fog::AWS::Mock.request_id }
+              response.status = 200
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The user policy with name #{policy_name} cannot be found.")
+          end
+        end
+
+      end
     end
   end
 end

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

@@ -35,6 +35,27 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def list_access_keys(options = {})
+          #FIXME: Doesn't do anything with options, aside from UserName
+          user = options['UserName']
+
+          if data[:users].has_key? user
+            Excon::Response.new.tap do |response|
+              response.body = { 'AccessKeys' => data[:users][user][:access_keys].map do |akey|
+                                                  {'Status' => akey['Status'], 'AccessKeyId' => akey['AccessKeyId']}
+                                                end,
+                                 'IsTruncated' => false,
+                                 'RequestId' => Fog::AWS::Mock.request_id }
+              response.status = 200
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The user with name #{user} cannot be found.")
+          end
+        end
+      end
     end
   end
 end

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

@@ -37,6 +37,24 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def list_groups(options = {} )
+          #FIXME: Doesn't observe options
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.body = { 'Groups' => data[:groups].map do |name, group|
+                                            { 'GroupId'   => group[:group_id],
+                                              'GroupName' => name,
+                                              'Path'      => group[:path],
+                                              'Arn'       => (group[:arn]).strip }
+                                          end,
+                              'IsTruncated' => false,
+                              'RequestId' => Fog::AWS::Mock.request_id }
+          end
+        end
+      end
     end
   end
 end

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

@@ -38,6 +38,30 @@ module Fog
         end
 
       end
+
+      class Mock
+        def list_groups_for_user(user_name, options = {})
+          #FIXME: Does not consider options
+          if data[:users].has_key? user_name
+            Excon::Response.new.tap do |response|
+              response.status = 200
+              response.body = { 'GroupsForUser' => data[:groups].select do |name, group|
+                                                     group[:members].include? user_name
+                                                   end.map do |name, group|
+                                                     { 'GroupId'   => group[:group_id],
+                                                       'GroupName' => name,
+                                                       'Path'      => group[:path],
+                                                       'Arn'       => (group[:arn]).strip }
+                                                   end,
+                                'IsTruncated' => false,
+                                'RequestId' => Fog::AWS::Mock.request_id
+                              }
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+          end
+        end
+      end
     end
   end
 end

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

@@ -34,6 +34,24 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def list_user_policies(user_name, options = {})
+          #FIXME: doesn't use options atm
+          if data[:users].has_key? user_name
+            Excon::Response.new.tap do |response|
+              response.body = { 'PolicyNames' => data[:users][user_name][:policies].keys,
+                                'IsTruncated' => false,
+                                'RequestId'   => Fog::AWS::Mock.request_id }
+              response.status = 200
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+          end
+        end
+
+      end
     end
   end
 end

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

@@ -37,6 +37,23 @@ module Fog
         end
 
       end
+
+      class Mock
+        def list_users(options = {})
+          #FIXME: none of the options are currently supported
+          Excon::Response.new.tap do |response|
+            response.body = {'Users' => data[:users].map do |user, data|
+                                          { 'UserId'   => data[:user_id],
+                                            'Path'     => data[:path],
+                                            'UserName' => user,
+                                            'Arn'      => (data[:arn]).strip }
+                                        end,
+                             'IsTruncated' => false,
+                             'RequestId'   => Fog::AWS::Mock.request_id }
+            response.status = 200
+          end
+        end
+      end
     end
   end
 end

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

@@ -31,6 +31,24 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        #FIXME: You can't actually use the credentials for anything elsewhere in Fog
+        #FIXME: Doesn't do any validation on the policy
+        def put_user_policy(user_name, policy_name, policy_document)
+          if data[:users].has_key? user_name
+            data[:users][user_name][:policies][policy_name] = policy_document
+
+            Excon::Response.new.tap do |response|
+              response.body = { 'RequestId' => Fog::AWS::Mock.request_id }
+              response.status = 200
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+          end
+        end
+      end
     end
   end
 end

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

@@ -29,6 +29,25 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def remove_user_from_group(group_name, user_name)
+          if data[:groups].has_key? group_name
+            if data[:users].has_key? user_name
+              data[:groups][group_name][:members].delete_if { |item| item == user_name }
+              Excon::Response.new.tap do |response|
+                response.status = 200
+                response.body = { 'RequestId' => Fog::AWS::Mock.request_id }
+              end
+            else
+              raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The group with name #{group_name} cannot be found.")
+          end
+        end
+      end
     end
   end
 end

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

@@ -51,6 +51,9 @@ module Fog
 
           # Validate cert and key
           begin
+            # must be an RSA private key
+            raise OpenSSL::PKey::RSAError unless private_key =~ /BEGIN RSA PRIVATE KEY/
+
             cert = OpenSSL::X509::Certificate.new(certificate)
             chain = OpenSSL::X509::Certificate.new(options['CertificateChain']) if options['CertificateChain']
             key = OpenSSL::PKey::RSA.new(private_key)
@@ -71,7 +74,7 @@ module Fog
             raise Fog::AWS::IAM::EntityAlreadyExists.new
           else
             response.status = 200
-            path = options['path'] || "/"
+            path = options['Path'] || "/"
             data = {
               'Arn' => Fog::AWS::Mock.arn('iam', self.data[:owner_id], "server-certificate/#{name}"),
               'Path' => path,

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

@@ -33,7 +33,36 @@ module Fog
       class Mock
 
         def authorize_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')
+              if sec_group['IPRanges'].detect{|h| h['CIDRIP'] == opts['CIDRIP']}
+                raise Fog::AWS::RDS::AuthorizationAlreadyExists.new("AuthorizationAlreadyExists => #{opts['CIDRIP']} is alreay defined")
+              end
+              sec_group['IPRanges'] << opts.merge({"Status" => 'authorizing'})
+            else
+              if sec_group['EC2SecurityGroups'].detect{|h| h['EC2SecurityGroupName'] == opts['EC2SecurityGroupName']}
+                raise Fog::AWS::RDS::AuthorizationAlreadyExists.new("AuthorizationAlreadyExists => #{opts['EC2SecurityGroupName']} is alreay defined")
+              end
+              sec_group['EC2SecurityGroups'] << opts.merge({"Status" => 'authorizing'})
+            end
+            response.status = 200
+            response.body = {
+              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+              'AuthorizeDBSecurityGroupIngressResult' => {          
+                'DBSecurityGroup' => sec_group
+              }
+            }
+            response
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
+          end
+          
         end
 
       end

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

@@ -9,15 +9,15 @@ module Fog
         # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html
         # ==== Parameters
         # * DBInstanceIdentifier <~String> - name of the db instance to modify
-        #                                     
+        #
         # * AllocatedStorage  <~Integer> Storage space, in GB
-        # * AutoMinorVersionUpgrade <~Boolean> Indicates that minor version upgrades will be applied automatically to the DB Instance during the maintenance window 
+        # * AutoMinorVersionUpgrade <~Boolean> Indicates that minor version upgrades will be applied automatically to the DB Instance during the maintenance window
         # * AvailabilityZone <~String> The availability zone to create the instance in
         # * BackupRetentionPeriod  <~Integer> 0-8 The number of days to retain automated backups.
         # * DBInstanceClass <~String> The new compute and memory capacity of the DB Instance
         # * DBName <~String> The name of the database to create when the DB Instance is created
-        # * DBParameterGroupName <~String> The name of the DB Parameter Group to apply to this DB Instance  
-        # * DBSecurityGroups <~Array> A list of DB Security Groups to authorize on this DB Instance 
+        # * DBParameterGroupName <~String> The name of the DB Parameter Group to apply to this DB Instance
+        # * DBSecurityGroups <~Array> A list of DB Security Groups to authorize on this DB Instance
         # * Engine <~String> The name of the database engine to be used for this instance.
         # * EngineVersion <~String> The version number of the database engine to use.
         # * MasterUsername <~String> The db master user
@@ -30,11 +30,11 @@ module Fog
         # * response<~Excon::Response>:
         #   * body<~Hash>:
         def create_db_instance(db_name, options={})
-          
+
           if security_groups = options.delete('DBSecurityGroups')
             options.merge!(Fog::AWS.indexed_param('DBSecurityGroups.member.%d', [*security_groups]))
           end
-    
+
           request({
             'Action'  => 'CreateDBInstance',
             'DBInstanceIdentifier' => db_name,
@@ -47,7 +47,73 @@ module Fog
       class Mock
 
         def create_db_instance(db_name, options={})
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          if self.data[:servers] and self.data[:servers][db_name]
+            # I don't know how to raise an exception that contains the excon data
+            #response.status = 400
+            #response.body = {
+            #  'Code' => 'DBInstanceAlreadyExists',
+            #  'Message' => "DB Instance already exists"
+            #}
+            #return response
+            raise Fog::AWS::RDS::IdentifierTaken.new("DBInstanceAlreadyExists #{response.body.to_s}")
+          end
+
+          # These are the required parameters according to the API
+          required_params = %w{AllocatedStorage DBInstanceClass Engine MasterUserPassword MasterUsername }
+          required_params.each do |key|
+            unless options.has_key?(key) and options[key] and !options[key].to_s.empty?
+              #response.status = 400
+              #response.body = {
+              #  'Code' => 'MissingParameter',
+              #  'Message' => "The request must contain the parameter #{key}"
+              #}
+              #return response
+              raise Fog::AWS::RDS::NotFound.new("The request must contain the parameter #{key}")
+            end
+          end
+
+          data =
+              {
+                 "DBInstanceIdentifier"=> db_name,
+                 "DBName" => options["DBName"],
+                 "InstanceCreateTime" => nil,
+                 "AutoMinorVersionUpgrade"=>true,
+                 "Endpoint"=>{},
+                 "ReadReplicaDBInstanceIdentifiers"=>['bla'],
+                 "PreferredMaintenanceWindow"=>"mon:04:30-mon:05:00",
+                 "Engine"=> options["Engine"],
+                 "EngineVersion"=> options["EngineVersion"] || "5.1.57",
+                 "PendingModifiedValues"=>{"MasterUserPassword"=>"****"}, # This clears when is available
+                 "MultiAZ"=>false,
+                 "MasterUsername"=> options["MasterUsername"],
+                 "DBInstanceClass"=> options["DBInstanceClass"],
+                 "DBInstanceStatus"=>"creating",
+                 "BackupRetentionPeriod"=> options["BackupRetentionPeriod"] || 1,
+                 "AllocatedStorage"=> options["AllocatedStorage"],
+                 "DBParameterGroups"=> # I think groups should be in the self.data method
+                          [{"DBParameterGroupName"=>"default.mysql5.1",
+                            "ParameterApplyStatus"=>"in-sync"}],
+                 "DBSecurityGroups"=>
+                          [{"Status"=>"active", 
+                            "DBSecurityGroupName"=>"default"}],
+                 "LicenseModel"=>"general-public-license",
+                 "PreferredBackupWindow"=>"08:00-08:30",
+#                 "ReadReplicaSourceDBInstanceIdentifier" => nil,
+#                 "LatestRestorableTime" => nil,
+                 "AvailabilityZone" => options["AvailabilityZone"]
+             }
+
+
+          self.data[:servers][db_name] = data
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "CreateDBInstanceResult"=> {"DBInstance"=> data}
+          }
+          response.status = 200
+          # This values aren't showed at creating time but at available time
+          self.data[:servers][db_name]["InstanceCreateTime"] = Time.now
+          response
         end
 
       end

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

@@ -32,7 +32,25 @@ module Fog
       class Mock
 
         def create_db_parameter_group(group_name, group_family, description)
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          if self.data[:parameter_groups] and self.data[:parameter_groups][group_name]
+            raise Fog::AWS::RDS::IdentifierTaken.new("Parameter group #{group_name} already exists")
+          end
+          
+          data = {
+            'DBParameterGroupName' => group_name,
+            'DBParameterGroupFamily' => group_family.downcase,
+            'Description' => description
+          }
+          self.data[:parameter_groups][group_name] = data
+          
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "CreateDBParameterGroupResult"=> {"DBParameterGroup"=> data}
+          }
+          response.status = 200
+          response
+          
         end
 
       end

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

@@ -27,7 +27,25 @@ module Fog
       class Mock
 
         def create_db_security_group(name, description = name)
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          if self.data[:security_groups] and self.data[:security_groups][name]
+            raise Fog::AWS::RDS::IdentifierTaken.new("DBInstanceAlreadyExists => The security group '#{name}' already exists")
+          end
+          
+          data = {
+            'DBSecurityGroupName' => name,
+            'DBSecurityGroupDescription' => description,
+            'EC2SecurityGroups' => [],
+            'IPRanges' => [],
+            'OwnerId' => '0123456789'
+          }
+          self.data[:security_groups][name] = data
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            'CreateDBSecurityGroupResult' => { 'DBSecurityGroup' => data }
+          }
+          response
+          
         end
 
       end

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

@@ -27,9 +27,45 @@ module Fog
       class Mock
 
         def create_db_snapshot(identifier, name)
-          Fog::Mock.not_implemented
-        end
+          response = Excon::Response.new
+          if data[:snapshots][name]
+            raise Fog::AWS::RDS::IndentifierTaken.new
+          end
+
+          server_data = data[:servers][identifier]
+          unless server_data
+            raise Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found")
+          end
+
+          # TODO: raise an error if the server isn't in 'available' state
+
+          snapshot_data = {
+            'Status'               => 'creating',
+            #'SnapshotType'         => 'manual', # In a newer RDS version
+            'DBInstanceIdentifier' => identifier,
+            'DBSnapshotIdentifier' => name,
+            'InstanceCreateTime'   => Time.now
+          }
+          # Copy attributes from server
+          %w(Engine EngineVersion AvailabilityZone AllocatedStorage MasterUsername InstanceCreateTime).each do |key|
+            snapshot_data[key] = server_data[key]
+          end
+          snapshot_data['Port'] = server_data['Endpoint']['Port']
+
+          self.data[:snapshots][name] = snapshot_data
+
+          # TODO: put the server in 'modifying' state
 
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "CreateDBSnapshotResult"=> {"DBSnapshot"=> snapshot_data.dup}
+          }
+          response.status = 200
+          # SnapshotCreateTime is not part of the response.
+          self.data[:snapshots][name]['SnapshotCreateTime'] = Time.now
+          response
+
+        end
       end
     end
   end

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

@@ -15,7 +15,7 @@ module Fog
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
-        def delete_db_instance(identifier, snapshot_identifier, skip_snapshot = false)          
+        def delete_db_instance(identifier, snapshot_identifier, skip_snapshot = false) 
           params = {}
           params['FinalDBSnapshotIdentifier'] = snapshot_identifier if snapshot_identifier
           request({
@@ -30,8 +30,23 @@ module Fog
 
       class Mock
 
-        def delete_db_snapshot(identifier, snapshot_identifier, skip_snapshot = false)
-          Fog::Mock.not_implemented
+        def delete_db_instance(identifier, snapshot_identifier, skip_snapshot = false)
+          response = Excon::Response.new
+          
+          unless skip_snapshot
+            create_db_snapshot(identifier, snapshot_identifier)
+          end
+          
+          if server_set = self.data[:servers].delete(identifier)
+            response.status = 200
+            response.body = {
+              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+              "DeleteDBInstanceResult" => { "DBInstance" => server_set }
+            }
+            response
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found")
+          end
         end
 
       end

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
@@ -33,9 +33,64 @@ module Fog
       class Mock
 
         def describe_db_instances(identifier=nil, opts={})
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          server_set = []
+          if identifier
+            if server = self.data[:servers][identifier]
+              server_set << server
+            else
+              raise Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found")
+            end
+          else
+            server_set = self.data[:servers].values
+          end
+
+          server_set.each do |server|
+             case server["DBInstanceStatus"]
+             when "creating"
+                 if Time.now - server['InstanceCreateTime'] >= Fog::Mock.delay * 2
+                   region = "us-east-1"
+                   server["DBInstanceStatus"] = "available"
+                   server["AvailabilityZone"] = region + 'a'
+                   server["Endpoint"] = {"Port"=>3306, 
+                                         "Address"=> Fog::AWS::Mock.rds_address(server["DBInstanceIdentifier"],region) }
+                   server["PendingModifiedValues"] = {}
+                 end
+              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
+              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 },
+            "DescribeDBInstancesResult" => { "DBInstances" => server_set }
+          }
+          response
         end
 
+
       end
     end
   end