class Fog::Compute::Linode::Mock

request :linode_resize

Public Class Methods

data() click to toggle source
# File lib/fog/linode/compute.rb, line 65
def self.data
  @data ||= Hash.new do |hash, key|
    hash[key] = {}
  end
end
new(options={}) click to toggle source
# File lib/fog/linode/compute.rb, line 75
def initialize(options={})
  @linode_api_key = options[:linode_api_key]
end
reset() click to toggle source
# File lib/fog/linode/compute.rb, line 71
def self.reset
  @data = nil
end

Public Instance Methods

avail_datacenters() click to toggle source
# File lib/fog/linode/requests/compute/avail_datacenters.rb, line 21
def avail_datacenters
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "DATA" => [
      { "LOCATION" => "Dallas, TX, USA",     "DATACENTERID" => 2,  "ABBR" => "dallas" },
      { "LOCATION" => "Fremont, CA, USA",    "DATACENTERID" => 3,  "ABBR" => "fremont" },
      { "LOCATION" => "Atlanta, GA, USA",    "DATACENTERID" => 4,  "ABBR" => "atlanta" },
      { "LOCATION" => "Newark, NJ, USA",     "DATACENTERID" => 6,  "ABBR" => "newark" },
      { "LOCATION" => "London, England, UK", "DATACENTERID" => 7,  "ABBR" => "london" },
      { "LOCATION" => "Tokyo, JP",           "DATACENTERID" => 8,  "ABBR" => "tokyo" },
      { "LOCATION" => "Singapore, SGP",      "DATACENTERID" => 9,  "ABBR" => "singapore" },
      { "LOCATION" => "Frankfurt, DE",       "DATACENTERID" => 10, "ABBR" => "frankfurt" },
      { "LOCATION" => "Tokyo 2, JP",         "DATACENTERID" => 11, "ABBR" => "tokyo2" },
    ],
    "ACTION" => "avail.datacenters"
  }
  response
end
avail_distributions(distribution_id=nil) click to toggle source
# File lib/fog/linode/requests/compute/avail_distributions.rb, line 28
def avail_distributions(distribution_id=nil)
  response = Excon::Response.new
  response.status = 200

  body = {
    "ERRORARRAY" => [],
    "ACTION" => "avail.distributions"
  }
  if distribution_id
    mock_distribution = create_mock_distribution(distribution_id)
    response.body = body.merge("DATA" => [mock_distribution])
  else
    mock_distributions = []
    10.times do
      distribution_id = rand(1..99)
      mock_distributions << create_mock_distribution(distribution_id)
    end
    response.body = body.merge("DATA" => mock_distributions)
  end
  response
end
avail_kernels(options={}) click to toggle source
# File lib/fog/linode/requests/compute/avail_kernels.rb, line 28
def avail_kernels(options={})
  # avail.kernels used to accept a kernelId parameter (now removed)
  raise Fog::Errors::Error.new('avail_kernels no longer accepts a kernelId parameter') unless !options || options.is_a?(Hash)

  response = Excon::Response.new
  response.status = 200

  body = {
    "ERRORARRAY" => [],
    "ACTION" => "avail.kernels"
  }
  mock_kernels = []
  10.times do
    kernel_id = rand(1..200)
    mock_kernels << create_mock_kernel(kernel_id)
  end
  response.body = body.merge("DATA" => mock_kernels)
  response
end
avail_linodeplans(linodeplan_id = nil) click to toggle source
# File lib/fog/linode/requests/compute/avail_linodeplans.rb, line 30
def avail_linodeplans(linodeplan_id = nil)
  response = Excon::Response.new
  response.status = 200
  body = {
    "ERRORARRAY" => [],
    "ACTION" => "avail.linodeplans"
  }
  if linodeplan_id
    mock_plan = create_mock_linodeplan(linodeplan_id)
    response.body = body.merge("DATA" => [mock_plan])
  else
    mock_plans = []
    10.times do
      plan_id = rand(1..99)
      mock_plans << create_mock_linodeplan(plan_id)
    end
    response.body = body.merge("DATA" => mock_plans)
  end
  response
end
avail_nodebalancers() click to toggle source
# File lib/fog/linode/requests/compute/avail_nodebalancers.rb, line 25
def avail_nodebalancers
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION" => "avail.nodebalancers",
    "DATA" => [{
      "MONTHLY" => 20.0,
      "HOURLY" => 0.03,
      "CONNECTIONS" => 10000
    }]
  }
  response
end
avail_stackscripts(options={}) click to toggle source
# File lib/fog/linode/requests/compute/avail_stackscripts.rb, line 17
def avail_stackscripts(options={})
  response = Excon::Response.new
  response.status = 200

  body = {
    "ERRORARRAY" => [],
    "ACTION" => "avail.stackscripts"
  }
  mock_stackscripts = []
  10.times do
    stackscript_id = rand(1..200)
    mock_stackscripts << create_mock_stackscript(stackscript_id)
  end
  response.body = body.merge("DATA" => mock_stackscripts)
  response
end
data() click to toggle source
# File lib/fog/linode/compute.rb, line 79
def data
  self.class.data[@linode_api_key]
end
image_delete(image_id, status='available') click to toggle source
# File lib/fog/linode/requests/compute/image_delete.rb, line 18
def image_delete(image_id, status='available')
  size = rand(1..999999)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "image.delete",
    "DATA"       => { "LAST_USED_DT" => "2014-07-21 12:31:54.0",
                      "DESCRIPTION" => "Fog Mock Linode Image #{image_id}",
                      "LABEL" => "test_#{image_id}_image",
                      "STATUS" => status,
                      "SIZE" => size,
                      "ISPUBLIC" => rand(0..1),
                      "CREATE_DT" => "2014-06-23 13:45:12.0",
                      "USED" => rand(1..size),
                      "FS_TYPE" => "ext4",
                      "USERID" => Fog::Mock.random_numbers(4),
                      "IMAGEID" => image_id }
  }
  response
end
image_list(pending=nil, image_id=nil) click to toggle source
# File lib/fog/linode/requests/compute/image_list.rb, line 22
def image_list(pending=nil, image_id=nil)
  response = Excon::Response.new
  response.status = 200
  body = {
    "ERRORARRAY" => [],
    "ACTION" => "image.list"
  }
  if image_id
    mock_image = create_mock_image(image_id)
    response.body = body.merge("DATA" => [mock_image])
  else
    mock_images = []
    rand(1..3).times do
      image_id = Fog::Mock.random_numbers(5)
      mock_images << create_mock_image(image_id)
    end
    response.body = body.merge("DATA" => mock_images)
  end
  response
end
linode_boot(linode_id, config_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_boot.rb, line 15
def linode_boot(linode_id, config_id)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.boot",
    "DATA"       => { "JobID" => rand(1000..9999) }
  }
  response
end
linode_config_create(linode_id, kernel_id, name, disk_list) click to toggle source
# File lib/fog/linode/requests/compute/linode_config_create.rb, line 21
def linode_config_create(linode_id, kernel_id, name, disk_list)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.boot",
    "DATA"       => { "ConfigID" => rand(10000..99999) }
  }
  response
end
linode_config_delete(linode_id, config_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_config_delete.rb, line 19
def linode_config_delete(linode_id, config_id)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.config.delete",
    "DATA"       => { "ConfigID" => rand(10000..99999) }
  }
  response
end
linode_config_list(linode_id, config_id=nil, options={}) click to toggle source
# File lib/fog/linode/requests/compute/linode_config_list.rb, line 18
def linode_config_list(linode_id, config_id=nil, options={})
  response = Excon::Response.new
  response.status = 200

  body = {
    "ERRORARRAY" => [],
    "ACTION" => "linode.config.list"
  }
  if config_id
    mock_config = create_mock_config(linode_id, config_id)
    response.body = body.merge("DATA" => [mock_config])
  else
    mock_configs = []
    5.times do
      linode_id = rand(10000..99999)
      config_id = rand(10000..99999)
      mock_configs << create_mock_config(linode_id, config_id)
    end
    response.body = body.merge("DATA" => mock_configs)
  end
  response
end
linode_config_update(linode_id, config_id, options={}) click to toggle source
# File lib/fog/linode/requests/compute/linode_config_update.rb, line 20
def linode_config_update(linode_id, config_id, options={})
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.config.update",
    "DATA"       => { "ConfigID" => rand(10000..99999) }
  }
  response
end
linode_create(datacenter_id, plan_id, payment_term) click to toggle source
# File lib/fog/linode/requests/compute/linode_create.rb, line 31
def linode_create(datacenter_id, plan_id, payment_term)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.create",
    "DATA"       => { "LinodeID" => rand(1000..9999) }
  }
  response
end
linode_delete(linode_id, options={}) click to toggle source
# File lib/fog/linode/requests/compute/linode_delete.rb, line 26
def linode_delete(linode_id, options={})
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.delete",
    "DATA"       => { "LinodeID" => linode_id }
  }
  response
end
linode_disk_create(linode_id, name, type, size) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_create.rb, line 21
def linode_disk_create(linode_id, name, type, size)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.disk.create",
    "DATA"       => { "JobID" => rand(1000..9999),
                      "DiskID" => rand(10000..99999) }
  }
  response
end
linode_disk_createfromdistribution(linode_id, distro_id, name, size, password) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_createfromdistribution.rb, line 22
def linode_disk_createfromdistribution(linode_id, distro_id, name, size, password)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.disk.createFromDistribution",
    "DATA"       => { "JobID" => rand(1000..9999),
                      "DiskID" => rand(10000..99999) }
  }
  response
end
linode_disk_createfromimage(linode_id, image_id, label, size, password, sshkey) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_createfromimage.rb, line 23
def linode_disk_createfromimage(linode_id, image_id, label, size, password, sshkey)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.disk.createfromimage",
    "DATA"       => { "JobID" => Fog::Mock.random_numbers(4),
                      "DiskID" => Fog::Mock.random_numbers(5) }
  }
  response
end
linode_disk_delete(linode_id, disk_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_delete.rb, line 19
def linode_disk_delete(linode_id, disk_id)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.disk.delete",
    "DATA"       => { "JobID" => rand(1000..9999),
                      "DiskID" => disk_id }
  }
  response
end
linode_disk_duplicate(linode_id, disk_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_duplicate.rb, line 19
def linode_disk_duplicate(linode_id, disk_id)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.disk.duplicate",
    "DATA"       => { "JobID" => Fog::Mock.random_numbers(4),
                      "DiskID" => Fog::Mock.random_numbers(5) }
  }
  response
end
linode_disk_imagize(linode_id, disk_id, description, label) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_imagize.rb, line 21
def linode_disk_imagize(linode_id, disk_id, description, label)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.disk.imagize",
    "DATA"       => {
      "JobID" => Fog::Mock.random_numbers(4),
      "ImageID" => Fog::Mock.random_numbers(4)
    }
  }
  response
end
linode_disk_list(linode_id, disk_id=nil) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_list.rb, line 19
def linode_disk_list(linode_id, disk_id=nil)
  response = Excon::Response.new
  response.status = 200
  body = {
    "ERRORARRAY" => [],
    "ACTION" => "linode.disk.list"
  }
  if disk_id
    mock_disk = create_mock_disk(linode_id, disk_id)
    response.body = body.merge("DATA" => [mock_disk])
  else
    mock_disks = []
    2.times do
      disk_id = rand(10000..99999)
      mock_disks << create_mock_disk(linode_id, disk_id)
    end
    response.body = body.merge("DATA" => mock_disks)
  end
  response
end
linode_disk_resize(linode_id, disk_id, size) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_resize.rb, line 20
def linode_disk_resize(linode_id, disk_id, size)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.disk.resize",
    "DATA"       => {
      "JobID" => Fog::Mock.random_numbers(4),
      "DiskID" => Fog::Mock.random_numbers(4)
    }
  }
  response
end
linode_disk_update(linode_id, disk_id, label, isreadonly) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_update.rb, line 21
def linode_disk_update(linode_id, disk_id, label, isreadonly)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.disk.update",
    "DATA"       => { "DiskID" => Fog::Mock.random_numbers(5) }
  }
  response
end
linode_ip_list(linode_id, ip_id=nil) click to toggle source
# File lib/fog/linode/requests/compute/linode_ip_list.rb, line 19
def linode_ip_list(linode_id, ip_id=nil)
  response = Excon::Response.new
  response.status = 200
  body = {
    "ERRORARRAY" => [],
    "ACTION" => "linode.ip.list"
  }

  if ip_id
    # one IP
    mock_ip = create_mock_ip(ip_id)
    response.body = body.merge("DATA" => [mock_ip])
  else
    # all IPs
    mock_ips = []
    ip_id = rand(10000..99999)
    mock_ips << create_mock_ip(linode_id, ip_id)
    ip_id = rand(10000..99999)
    mock_ips << create_mock_ip(linode_id, ip_id, false)
    response.body = body.merge("DATA" => mock_ips)
  end
  response
end
linode_list(linode_id=nil) click to toggle source
# File lib/fog/linode/requests/compute/linode_list.rb, line 28
def linode_list(linode_id=nil)
  body = {
    "ERRORARRAY" => [],
    "ACTION" => "linode.list"
  }
  response = Excon::Response.new
  response.status = 200
  if linode_id
    # one server
    mock_server = create_mock_server(linode_id)
    response.body = body.merge("DATA" => [mock_server])
  else
    # all servers
    mock_servers = []
    5.times do
      linode_id = rand(100000..999999)
      mock_servers << create_mock_server(linode_id)
    end
    response.body = body.merge("DATA" => mock_servers)
  end
  response
end
linode_reboot(linode_id, options={}) click to toggle source
# File lib/fog/linode/requests/compute/linode_reboot.rb, line 26
def linode_reboot(linode_id, options={})
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.reboot",
    "DATA"       => { "JobID" => rand(1000..9999) }
  }
  response
end
linode_shutdown(linode_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_shutdown.rb, line 15
def linode_shutdown(linode_id)
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.shutdown",
    "DATA"       => { "JobID" => rand(1000..9999) }
  }
  response
end
linode_update(linode_id, options={}) click to toggle source
# File lib/fog/linode/requests/compute/linode_update.rb, line 15
def linode_update(linode_id, options={})
  response = Excon::Response.new
  response.status = 200
  response.body = {
    "ERRORARRAY" => [],
    "ACTION"     => "linode.update",
    "DATA"       => { "LinodeID" => rand(1000..9999) }
  }
  response
end
reset_data() click to toggle source
# File lib/fog/linode/compute.rb, line 83
def reset_data
  self.class.data.delete(@linode_api_key)
end

Private Instance Methods

create_mock_config(linode_id, config_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_config_list.rb, line 43
def create_mock_config(linode_id, config_id)
  {
    "Comments"               => "",
    "ConfigID"               => config_id,
    "DiskList"               => "839421,839420,,,,,,,",
    "KernelID"               => 137,
    "Label"                  => "test_#{linode_id}",
    "LinodeID"               => linode_id,
    "RAMLimit"               => 0,
    "RootDeviceCustom"       => "",
    "RootDeviceNum"          => 1,
    "RootDeviceRO"           => true,
    "RunLevel"               => "default",
    "__validationErrorArray" => [],
    "apiColumnFilterStruct"  => "",
    "devtmpfs_automount"     => true,
    "helper_depmod"          => 1,
    "helper_disableUpdateDB" => 1,
    "helper_libtls"          => 0,
    "helper_xen"             => 1,
    "isRescue"               => 0
  }
end
create_mock_disk(linode_id, disk_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_list.rb, line 42
def create_mock_disk(linode_id, disk_id)
  {
    "CREATE_DT"  => "2012-02-29 12:55:29.0",
    "DISKID"     => disk_id,
    "ISREADONLY" => 0,
    "LABEL"      => "test_#{linode_id}_main",
    "LINODEID"   => linode_id,
    "SIZE"       => 39936,
    "STATUS"     => 1,
    "TYPE"       => "ext3",
    "UPDATE_DT"  => "2012-02-29 12:55:53.0"
  }
end
create_mock_distribution(distribution_id) click to toggle source
# File lib/fog/linode/requests/compute/avail_distributions.rb, line 52
def create_mock_distribution(distribution_id)
  {
    "CREATE_DT"           => "2012-04-26 17:25:16.0",
    "DISTRIBUTIONID"      => distribution_id,
    "IS64BIT"             => 0,
    "LABEL"               => "Ubuntu 12.04 LTS",
    "MINIMAGESIZE"        => 600,
    "REQUIRESPVOPSKERNEL" => 1
  }
end
create_mock_image(image_id, status='available') click to toggle source
# File lib/fog/linode/requests/compute/image_list.rb, line 45
def create_mock_image(image_id, status='available')
  size = rand(1...999999)
  {
    "LAST_USED_DT" => "2014-07-29 12:55:29.0",
    "DESCRIPTION" => "Fog Mock Linode Image #{image_id}",
    "LABEL"      => "test_#{image_id}_image",
    "STATUS"     => status,
    "TYPE"       => "manual",
    "ISPUBLIC"   => rand(0...1),
    "CREATE_DT"  => "2014-06-29 5:39:19.0",
    "MINSIZE"    => Fog::Mock.random_numbers(5),
    "FS_TYPE"    => "ext4",
    "CREATOR"    => "test_username",
    "IMAGEID"    => image_id
  }
end
create_mock_ip(linode_id, ip_id, is_public=true) click to toggle source
# File lib/fog/linode/requests/compute/linode_ip_list.rb, line 45
def create_mock_ip(linode_id, ip_id, is_public=true)
  {
    "IPADDRESSID" => ip_id,
    "RDNS_NAME" => "li-test.members.linode.com",
    "LINODEID" => linode_id,
    "ISPUBLIC" => is_public ? 1 : 0,
    "IPADDRESS" => is_public ? "1.2.3.4" : "192.168.1.2"
  }
end
create_mock_kernel(kernel_id) click to toggle source
# File lib/fog/linode/requests/compute/avail_kernels.rb, line 50
def create_mock_kernel(kernel_id)
  {
    "ISPVOPS"  => 1,
    "ISXEN"    => 1,
    "ISKVM"    => 1,
    "KERNELID" => kernel_id,
    "LABEL"    => "Latest 3.0 (3.0.18-linode43)"
  }
end
create_mock_linodeplan(linodeplan_id) click to toggle source
# File lib/fog/linode/requests/compute/avail_linodeplans.rb, line 53
def create_mock_linodeplan(linodeplan_id)
  { "PRICE" => 19.95, "RAM" => 512, "XFER" => 200,
    "PLANID" => linodeplan_id, "LABEL" => "Linode #{linodeplan_id}",
    "DISK" => 20,
    "CORES" => 1,
    "AVAIL" => {
      "2" => 500, "3" => 500, "4" => 500, "6" => 500, "7" => 500,
      "8" => 500, "9" => 500, "10" => 500
    },
    "HOURLY" => 0.03
  }
end
create_mock_server(linode_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_list.rb, line 53
def create_mock_server(linode_id)
  { "ALERT_CPU_ENABLED"       => 1,
    "ALERT_BWIN_ENABLED"      => 1,
    "BACKUPSENABLED"          => 0,
    "ALERT_CPU_THRESHOLD"     => 90,
    "ALERT_BWQUOTA_ENABLED"   => 1,
    "LABEL"                   => "test_#{linode_id}",
    "ALERT_DISKIO_THRESHOLD"  => 1000,
    "BACKUPWEEKLYDAY"         => 0,
    "BACKUPWINDOW"            => 0,
    "WATCHDOG"                => 1,
    "DATACENTERID"            => 6,
    "STATUS"                  => 1,
    "ALERT_DISKIO_ENABLED"    => 1,
    "TOTALHD"                 => 40960,
    "LPM_DISPLAYGROUP"        => "",
    "TOTALXFER"               => 400,
    "ALERT_BWQUOTA_THRESHOLD" => 80,
    "TOTALRAM"                => 1024,
    "LINODEID"                => linode_id,
    "ALERT_BWIN_THRESHOLD"    => 5,
    "ALERT_BWOUT_THRESHOLD"   => 5,
    "ALERT_BWOUT_ENABLED"     => 1
  }
end
create_mock_stackscript(stackscript_id) click to toggle source
# File lib/fog/linode/requests/compute/avail_stackscripts.rb, line 36
def create_mock_stackscript(stackscript_id)
  {
    "CREATE_DT"          => "2011-10-07 00:28:13.0",
    "DEPLOYMENTSACTIVE"  => 0,
    "DEPLOYMENTSTOTAL"   => 1,
    "DESCRIPTION"        => "Prints 'foobar' to the screen. Magic!",
    "DISTRIBUTIONIDLIST" => "77,78,64,65,82,83,50,51,73,74,41,42",
    "ISPUBLIC"           => 1,
    "LABEL"              => "foobar",
    "LATESTREV"          => 15149,
    "REV_DT"             => "2011-10-07 00:33:58.0",
    "REV_NOTE"           => "Updated update_rubygems_install function.",
    "SCRIPT"             => "#!/bin/bash\n#\n#\n\necho \"foobar\"",
    "STACKSCRIPTID"      => stackscript_id,
    "USERID"             => 1
  }
end