brightbox-cli 0.17.1 → 0.17.2

data/lib/brightbox-cli/vendor/fog/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/brightbox-cli/vendor/fog/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/brightbox-cli/vendor/fog/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
+            Fog::AWS::IAM::NotFound.new("The user with name #{user} cannot be found.")
+          end
+        end
+      end
     end
   end
 end

data/lib/brightbox-cli/vendor/fog/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] }
+                                          end,
+                              'IsTruncated' => false,
+                              'RequestId' => Fog::AWS::Mock.request_id }
+          end
+        end
+      end
     end
   end
 end

data/lib/brightbox-cli/vendor/fog/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] }
+                                                   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/brightbox-cli/vendor/fog/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/brightbox-cli/vendor/fog/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] }
+                                        end,
+                             'IsTruncated' => false,
+                             'RequestId'   => Fog::AWS::Mock.request_id }
+            response.status = 200
+          end
+        end
+      end
     end
   end
 end

data/lib/brightbox-cli/vendor/fog/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/brightbox-cli/vendor/fog/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/brightbox-cli/vendor/fog/lib/fog/aws/requests/iam/upload_server_certificate.rb

@@ -71,7 +71,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/brightbox-cli/vendor/fog/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/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/create_db_instance.rb

@@ -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/brightbox-cli/vendor/fog/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/brightbox-cli/vendor/fog/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,24 @@ 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
+            # I don't know how to mock snapshot_identifier
+            Fog::Logger.warning("snapshot_identifier is not mocked [light_black](#{caller.first})[/]")
+          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/brightbox-cli/vendor/fog/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