fog 1.1.2 → 1.2.0

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

@@ -27,6 +27,23 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def delete_user(user_name)
+          if data[:users].has_key? user_name
+            data[:users].delete user_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 with name #{user_name} cannot be found.")
+          end
+
+        end
+
+      end
     end
   end
 end

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,
@@ -58,7 +58,7 @@ module Fog
             #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|
@@ -72,15 +72,15 @@ module Fog
               raise Fog::AWS::RDS::NotFound.new("The request must contain the parameter #{key}")
             end
           end
-          
+
           data =
               {
                  "DBInstanceIdentifier"=> db_name,
                  "DBName" => options["DBName"],
-                 "created_at" => nil,
+                 "InstanceCreateTime" => nil,
                  "AutoMinorVersionUpgrade"=>true,
                  "Endpoint"=>{},
-                 "ReadReplicaDBInstanceIdentifiers"=>[],
+                 "ReadReplicaDBInstanceIdentifiers"=>['bla'],
                  "PreferredMaintenanceWindow"=>"mon:04:30-mon:05:00",
                  "Engine"=> options["Engine"],
                  "EngineVersion"=> options["EngineVersion"] || "5.1.57",
@@ -91,17 +91,20 @@ module Fog
                  "DBInstanceStatus"=>"creating",
                  "BackupRetentionPeriod"=> options["BackupRetentionPeriod"] || 1,
                  "AllocatedStorage"=> options["AllocatedStorage"],
-                 "DBParameterGroups"=> # I think groups shoul be in the self.data method
+                 "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"
+                 "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 },
@@ -109,7 +112,7 @@ module Fog
           }
           response.status = 200
           # This values aren't showed at creating time but at available time
-          self.data[:servers][db_name]["created_at"] = Time.now
+          self.data[:servers][db_name]["InstanceCreateTime"] = Time.now
           response
         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