Parent

Files

Class/Module Index [+]

Quicksearch

Fog::AWS::RDS::Mock

Public Class Methods

data() click to toggle source
# File lib/fog/aws/rds.rb, line 60
def self.data
  @data ||= Hash.new do |hash, region|
    owner_id = Fog::AWS::Mock.owner_id
    hash[region] = Hash.new do |region_hash, key|
      region_hash[key] = {
        :servers => {}
      }
    end
  end
end
new(options={}) click to toggle source
# File lib/fog/aws/rds.rb, line 75
def initialize(options={})

  @aws_access_key_id = options[:aws_access_key_id]

  @region = options[:region] || 'us-east-1'

  unless ['ap-northeast-1', 'ap-southeast-1', 'eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2'].include?(@region)
    raise ArgumentError, "Unknown region: #{@region.inspect}"
  end

end
reset() click to toggle source
# File lib/fog/aws/rds.rb, line 71
def self.reset
  @data = nil
end

Public Instance Methods

authorize_db_security_group_ingress(name, opts = {}) click to toggle source
# File lib/fog/aws/requests/rds/authorize_db_security_group_ingress.rb, line 35
def authorize_db_security_group_ingress(name, opts = {})
  Fog::Mock.not_implemented
end
create_db_instance(db_name, options={}) click to toggle source
# File lib/fog/aws/requests/rds/create_db_instance.rb, line 49
def create_db_instance(db_name, options={})
  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 = %{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"],
         "created_at" => nil,
         "AutoMinorVersionUpgrade"=>true,
         "Endpoint"=>{},
         "ReadReplicaDBInstanceIdentifiers"=>[],
         "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 shoul 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"
     }
   
  
  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]["created_at"] = Time.now
  response
end
create_db_instance_read_replica(instance_identifier, source_identifier, options={}) click to toggle source
# File lib/fog/aws/requests/rds/create_db_instance_read_replica.rb, line 35
def create_db_instance_read_replica(instance_identifier, source_identifier, options={})
  Fog::Mock.not_implemented
end
create_db_parameter_group(group_name, group_family, description) click to toggle source
# File lib/fog/aws/requests/rds/create_db_parameter_group.rb, line 34
def create_db_parameter_group(group_name, group_family, description)
  Fog::Mock.not_implemented
end
create_db_security_group(name, description = name) click to toggle source
# File lib/fog/aws/requests/rds/create_db_security_group.rb, line 29
def create_db_security_group(name, description = name)
  Fog::Mock.not_implemented
end
create_db_snapshot(identifier, name) click to toggle source
# File lib/fog/aws/requests/rds/create_db_snapshot.rb, line 29
def create_db_snapshot(identifier, name)
  Fog::Mock.not_implemented
end
data() click to toggle source
# File lib/fog/aws/rds.rb, line 87
def data
  self.class.data[@region][@aws_access_key_id]
end
delete_db_instance(identifier, snapshot_identifier, skip_snapshot = false) click to toggle source
# File lib/fog/aws/requests/rds/delete_db_instance.rb, line 33
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
delete_db_parameter_group(group_name) click to toggle source
# File lib/fog/aws/requests/rds/delete_db_parameter_group.rb, line 29
def delete_db_parameter_group(group_name)
  Fog::Mock.not_implemented
end
delete_db_security_group(name, description = name) click to toggle source
# File lib/fog/aws/requests/rds/delete_db_security_group.rb, line 27
def delete_db_security_group(name, description = name)
  Fog::Mock.not_implemented
end
delete_db_snapshot(group_name) click to toggle source
# File lib/fog/aws/requests/rds/delete_db_snapshot.rb, line 29
def delete_db_snapshot(group_name)
  Fog::Mock.not_implemented
end
describe_db_engine_versions(opts={}) click to toggle source
# File lib/fog/aws/requests/rds/describe_db_engine_versions.rb, line 27
def describe_db_engine_versions(opts={})
  Fog::Mock.not_implemented
end
describe_db_instances(identifier=nil, opts={}) click to toggle source
# File lib/fog/aws/requests/rds/describe_db_instances.rb, line 35
def describe_db_instances(identifier=nil, opts={})
  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['created_at'] >= Fog::Mock.delay * 2
           region = "us-east-1"
           server["DBInstanceStatus"] = "available"
           server["availability_zone"] = region + 'a'
           server["Endpoint"] = {"Port"=>3306, 
                                 "Address"=> Fog::AWS::Mock.rds_address(server["DBInstanceIdentifier"],region) }
           server["PendingModifiedValues"] = {}
         end
      when "rebooting"
        # it applies pending modified values
        if server["PendingModifiedValues"]
          server.merge!(server["PendingModifiedValues"])
          server["PendingModifiedValues"] = {}
          server["DBInstanceStatus"] = 'available'
        end
     end 
  end
  
  response.status = 200
  response.body = {
    "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
    "DescribeDBInstancesResult" => { "DBInstances" => server_set }
  }
  response
end
describe_db_parameter_groups(name=nil, opts={}) click to toggle source
# File lib/fog/aws/requests/rds/describe_db_parameter_groups.rb, line 38
def describe_db_parameter_groups(name=nil, opts={})
  Fog::Mock.not_implemented
end
describe_db_parameters(name, opts={}) click to toggle source
# File lib/fog/aws/requests/rds/describe_db_parameters.rb, line 39
def describe_db_parameters(name, opts={})
  Fog::Mock.not_implemented
end
describe_db_reserved_instances(identifier=nil, opts={}) click to toggle source
# File lib/fog/aws/requests/rds/describe_db_reserved_instances.rb, line 35
def describe_db_reserved_instances(identifier=nil, opts={})
  Fog::Mock.not_implemented
end
describe_db_security_group(opts={}) click to toggle source
# File lib/fog/aws/requests/rds/describe_db_security_groups.rb, line 31
def describe_db_security_group(opts={})
  Fog::Mock.not_implemented
end
describe_db_snapshots(opts={}) click to toggle source
# File lib/fog/aws/requests/rds/describe_db_snapshots.rb, line 35
def describe_db_snapshots(opts={})
  Fog::Mock.not_implemented
end
modify_db_instance(db_name, apply_immediately, options={}) click to toggle source
# File lib/fog/aws/requests/rds/modify_db_instance.rb, line 47
def modify_db_instance(db_name, apply_immediately, options={})
  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
      # 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
      response.status = 200
      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        "ModifyDBInstanceResult" => { "DBInstance" => modified_server }
      }
      response
      
    end
  else
    raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not found")
  end
end
modify_db_parameter_group(group_name, parameters) click to toggle source
# File lib/fog/aws/requests/rds/modify_db_parameter_group.rb, line 48
def modify_db_parameter_group(group_name, parameters)
  Fog::Mock.not_implemented
end
reboot_db_instance(instance_identifier) click to toggle source
# File lib/fog/aws/requests/rds/reboot_db_instance.rb, line 27
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")
    else
      server["DBInstanceStatus"] = 'rebooting'
      response.status = 200
      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        "RebootDBInstanceResult" => { "DBInstance" => server }
      }
      response
      
    end
  else
    raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not found")
  end
end
reset_data() click to toggle source
# File lib/fog/aws/rds.rb, line 91
def reset_data
  self.class.data[@region].delete(@aws_access_key_id)
end
restore_db_instance_from_db_snapshot(snapshot_id, db_id, options={}) click to toggle source
# File lib/fog/aws/requests/rds/restore_db_instance_from_db_snapshot.rb, line 26
def restore_db_instance_from_db_snapshot(snapshot_id, db_id, options={})
  Fog::Mock.not_implemented
end
restore_db_instance_to_point_in_time(source_db_name, target_db_name, opts={}) click to toggle source
# File lib/fog/aws/requests/rds/restore_db_instance_to_point_in_time.rb, line 26
def restore_db_instance_to_point_in_time(source_db_name, target_db_name, opts={})
  Fog::Mock.not_implemented
end
revoke_db_security_group_ingress(name, opts = {}) click to toggle source
# File lib/fog/aws/requests/rds/revoke_db_security_group_ingress.rb, line 35
def revoke_db_security_group_ingress(name, opts = {})
  Fog::Mock.not_implemented
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.