fog 1.5.0 → 1.6.0

data/tests/rackspace/models/compute_v2/servers_tests.rb

@@ -0,0 +1,14 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | servers', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  service = Fog::Compute::RackspaceV2.new
+  options = {
+    :name => "fog_server_#{Time.now.to_i.to_s}",
+    :flavor_id => 2,
+    :image_id => '3afe97b2-26dc-49c5-a2cc-a2fc8d80c001'
+  }
+  collection_tests(service.servers, options, false) do
+    @instance.wait_for { ready? }
+  end
+end

data/tests/rackspace/requests/block_storage/snapshot_tests.rb

@@ -0,0 +1,81 @@
+Shindo.tests('Fog::Rackspace::BlockStorage | snapshot_tests', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  SNAPSHOT_FORMAT = {
+    'id' => String,
+    'status' => String,
+    'display_name' => Fog::Nullable::String,
+    'display_description' => Fog::Nullable::String,
+    'volume_id' => String,
+    'size' => Integer,
+    'created_at' => String
+  }
+
+  GET_SNAPSHOT_FORMAT = {
+    'snapshot' => SNAPSHOT_FORMAT
+  }
+
+  LIST_SNAPSHOT_FORMAT = {
+    'snapshots' => [SNAPSHOT_FORMAT]
+  }
+
+  def snapshot_deleted?(service, snapshot_id)
+    begin
+      service.get_snapshot(snapshot_id)
+      false
+    rescue
+      true
+    end
+  end
+
+  service = Fog::Rackspace::BlockStorage.new
+
+  tests('success') do
+    volume = service.create_volume(10).body['volume']
+    volume_id = volume['id']
+    snapshot_id = nil
+
+    until service.get_volume(volume_id).body['volume']['status'] == 'available'
+      sleep 10
+    end
+
+    tests("#create_snapshot(#{volume_id})").formats(GET_SNAPSHOT_FORMAT) do
+      service.create_snapshot(volume_id).body.tap do |b|
+        snapshot_id = b['snapshot']['id']
+      end
+    end
+
+    tests("#list_snapshots").formats(LIST_SNAPSHOT_FORMAT) do
+      service.list_snapshots.body
+    end
+
+    tests("#get_snapshot(#{snapshot_id})").formats(GET_SNAPSHOT_FORMAT) do
+      service.get_snapshot(snapshot_id).body
+    end
+
+    until service.get_snapshot(snapshot_id).body['snapshot']['status'] == 'available' do
+      sleep 10
+    end
+
+    tests("#delete_snapshot(#{snapshot_id})").succeeds do
+      service.delete_snapshot(snapshot_id)
+    end
+
+    until snapshot_deleted?(service, snapshot_id)
+      sleep 10
+    end
+
+    service.delete_volume(volume_id)
+  end
+
+  tests('failure') do
+    tests("#create_snapshot('invalid')").raises(Fog::Rackspace::BlockStorage::NotFound) do
+      service.create_snapshot('invalid')
+    end
+
+    tests("#get_snapshot('invalid')").raises(Fog::Rackspace::BlockStorage::NotFound) do
+      service.get_snapshot('invalid')
+    end
+  end
+end

data/tests/rackspace/requests/block_storage/volume_tests.rb

@@ -0,0 +1,61 @@
+Shindo.tests('Fog::Rackspace::BlockStorage | volume_tests', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  VOLUME_FORMAT = {
+    'id' => String,
+    'status' => String,
+    'display_name' => Fog::Nullable::String,
+    'display_description' => Fog::Nullable::String,
+    'size' => Integer,
+    'created_at' => String,
+    'volume_type' => String,
+    'availability_zone' => String,
+    'snapshot_id' => Fog::Nullable::String,
+    'attachments' => Array,
+    'metadata' => Hash
+  }
+
+  GET_VOLUME_FORMAT = {
+    'volume' => VOLUME_FORMAT
+  }
+
+  LIST_VOLUME_FORMAT = {
+    'volumes' => [VOLUME_FORMAT]
+  }
+
+  service = Fog::Rackspace::BlockStorage.new
+
+  tests('success') do
+    id = nil
+    size = 10
+
+    tests("#create_volume(#{size})").formats(GET_VOLUME_FORMAT) do
+      data = service.create_volume(size).body
+      id = data['volume']['id']
+      data
+    end
+
+    tests("#list_volumes").formats(LIST_VOLUME_FORMAT) do
+      service.list_volumes.body
+    end
+
+    tests("#get_volume(#{id})").formats(GET_VOLUME_FORMAT) do
+      service.get_volume(id).body
+    end
+
+    tests("#delete_volume(#{id})").succeeds do
+      service.delete_volume(id)
+    end
+  end
+
+  tests('failure') do
+    tests("#create_volume(-1)").raises(Fog::Rackspace::BlockStorage::BadRequest) do
+      service.create_volume(-1)
+    end
+
+    tests("#get_volume(-1)").raises(Fog::Rackspace::BlockStorage::NotFound) do
+      service.get_volume(-1)
+    end
+  end
+end

data/tests/rackspace/requests/block_storage/volume_type_tests.rb

@@ -0,0 +1,31 @@
+Shindo.tests('Fog::Rackspace::BlockStorage | volume_type_tests', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  VOLUME_TYPE_FORMAT = {
+    'name' => String,
+    'extra_specs' => Hash
+  }
+
+  LIST_VOLUME_TYPE_FORMAT = {
+    'volume_types' => [VOLUME_TYPE_FORMAT.merge({ 'id' => Integer })]
+  }
+
+  GET_VOLUME_TYPE_FORMAT = {
+    'volume_type' => VOLUME_TYPE_FORMAT.merge({ 'id' => String })
+  }
+
+  service = Fog::Rackspace::BlockStorage.new
+
+  tests('success') do
+    volume_type_id = 1
+
+    tests("#list_volume_types").formats(LIST_VOLUME_TYPE_FORMAT) do
+      service.list_volume_types.body
+    end
+
+    tests("#get_volume_type(#{volume_type_id})").formats(GET_VOLUME_TYPE_FORMAT) do
+      service.get_volume_type(volume_type_id).body
+    end
+  end
+end

data/tests/rackspace/requests/compute_v2/attachment_tests.rb

@@ -0,0 +1,68 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | attachment_tests', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  ATTACHMENT_FORMAT = {
+    'volumeAttachment' => {
+      'id' => String,
+      'serverId' => String,
+      'volumeId' => String,
+      'device' => Fog::Nullable::String
+    }
+  }
+
+  LIST_ATTACHMENTS_FORMAT = {
+    'volumeAttachments' => [ATTACHMENT_FORMAT]
+  }
+
+  compute_service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+  block_storage_service = Fog::Rackspace::BlockStorage.new
+
+  name = 'fog' + Time.now.to_i.to_s
+  image_id = '3afe97b2-26dc-49c5-a2cc-a2fc8d80c001' # Ubuntu 11.10
+  flavor_id = '2' # 512 MB
+  server_id = compute_service.create_server(name, image_id, flavor_id, 1, 1).body['server']['id']
+  volume_id = block_storage_service.create_volume(1).body['volume']['id']
+  device_id = '/dev/xvde'
+
+
+  tests('success') do
+    until compute_service.get_server(server_id).body['server']['status'] == 'ACTIVE'
+      sleep 10
+    end
+
+    until block_storage_service.get_volume(volume_id).body['volume']['status'] == 'available'
+      sleep 10
+    end
+
+    tests("#attach_volume(#{server_id}, #{volume_id}, #{device_id})").formats(ATTACHMENT_FORMAT) do
+      compute_service.attach_volume(server_id, volume_id, device_id).body
+    end
+
+    tests("#list_attachments(#{server_id})").formats(LIST_ATTACHMENTS_FORMAT) do
+      compute_service.list_attachments(server_id).body
+    end
+
+    until block_storage_service.get_volume(volume_id).body['volume']['status'] == 'in-use'
+      sleep 10
+    end
+
+    tests("#get_attachment(#{server_id}, #{volume_id})").formats(ATTACHMENT_FORMAT) do
+      compute_service.get_attachment(server_id, volume_id).body
+    end
+
+    tests("#delete_attachment(#{server_id}, #{volume_id})").succeeds do
+      compute_service.delete_attachment(server_id, volume_id)
+    end
+  end
+
+  tests('failure') do
+    tests("#attach_volume('', #{volume_id}, #{device_id})").raises(Fog::Compute::RackspaceV2::NotFound) do
+      compute_service.attach_volume('', volume_id, device_id)
+    end
+
+    tests("#delete_attachment('', #{volume_id})").raises(Fog::Compute::RackspaceV2::NotFound) do
+      compute_service.delete_attachment('', volume_id)
+    end
+  end
+end

data/tests/rackspace/requests/compute_v2/flavor_tests.rb

@@ -0,0 +1,43 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | flavor_tests', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  FLAVOR_FORMAT = {
+    'id' => String,
+    'name' => String,
+    'ram' => Fog::Nullable::Integer,
+    'disk' => Fog::Nullable::Integer,
+    'vcpus' => Fog::Nullable::Integer,
+    'links' => [{
+      'rel' => String,
+      'href' => String
+    }]
+  }
+
+  LIST_FLAVOR_FORMAT = {
+    'flavors' => [FLAVOR_FORMAT]
+  }
+
+  GET_FLAVOR_FORMAT = {
+    'flavor' => FLAVOR_FORMAT.merge({
+      'OS-FLV-DISABLED:disabled' => Fog::Boolean,
+      'rxtx_factor' => Float,
+      'swap' => Integer
+    })
+  }
+
+  service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+  flavor_id = nil
+
+  tests('success') do
+    tests('#list_flavors').formats(LIST_FLAVOR_FORMAT) do
+      body = service.list_flavors.body
+      flavor_id = body['flavors'][0]['id']
+      body
+    end
+
+    tests('#get_flavor').formats(GET_FLAVOR_FORMAT) do
+      service.get_flavor(flavor_id).body
+    end
+  end
+end

data/tests/rackspace/requests/compute_v2/image_tests.rb

@@ -0,0 +1,47 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | image_tests', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  IMAGE_FORMAT = {
+    'id' => String,
+    'name' => String,
+    'created' => Fog::Nullable::String,
+    'updated' => Fog::Nullable::String,
+    'status' => Fog::Nullable::String,
+    'user_id' => Fog::Nullable::String,
+    'tenant_id' => Fog::Nullable::String,
+    'progress' => Fog::Nullable::Integer,
+    'minDisk' => Fog::Nullable::Integer,
+    'minRam' => Fog::Nullable::Integer,
+    'metadata' => Fog::Nullable::Hash,
+    'OS-DCF:diskConfig' => Fog::Nullable::String,
+    'links' => [{
+      'rel' => String,
+      'href' => String,
+      'type' => Fog::Nullable::String
+    }]
+  }
+
+  LIST_IMAGE_FORMAT = {
+    'images' => [IMAGE_FORMAT]
+  }
+
+  GET_IMAGE_FORMAT = {
+    'image' => IMAGE_FORMAT
+  }
+
+  service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+  image_id = nil
+
+  tests('success') do
+    tests('#list_images').formats(LIST_IMAGE_FORMAT) do
+      body = service.list_images.body
+      image_id = body['images'][0]['id']
+      body
+    end
+
+    tests('#get_image').formats(GET_IMAGE_FORMAT) do
+      service.get_image(image_id).body
+    end
+  end
+end

data/tests/rackspace/requests/compute_v2/server_tests.rb

@@ -0,0 +1,147 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | server_tests', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  LINK_FORMAT = {
+    'href' => String,
+    'rel' => String
+  }
+
+  SERVER_FORMAT = {
+    'id' => String,
+    'name' => String,
+    'hostId' => Fog::Nullable::String,
+    'created' => Fog::Nullable::String,
+    'updated' => Fog::Nullable::String,
+    'status' => Fog::Nullable::String,
+    'progress' => Fog::Nullable::Integer,
+    'user_id' => Fog::Nullable::String,
+    'tenant_id' => Fog::Nullable::String,
+    'links' => [LINK_FORMAT],
+    'metadata' => Fog::Nullable::Hash
+  }
+
+  LIST_SERVERS_FORMAT = {
+    'servers' => [SERVER_FORMAT]
+  }
+
+  GET_SERVER_FORMAT = {
+    'server' => SERVER_FORMAT.merge({
+      'accessIPv4' => String,
+      'accessIPv6' => String,
+      'OS-DCF:diskConfig' => String,
+      'rax-bandwidth:bandwidth' => Fog::Nullable::Array,
+      'addresses' => Fog::Nullable::Hash,
+      'flavor' => {
+        'id' => String,
+        'links' => [LINK_FORMAT]
+      },
+      'image' => {
+        'id' => String,
+        'links' => [LINK_FORMAT]
+      }
+    })
+  }
+
+  CREATE_SERVER_FORMAT = {
+    'server' => {
+      'id' => String,
+      'adminPass' => String,
+      'links' => [LINK_FORMAT],
+      'OS-DCF:diskConfig' => String
+    }
+  }
+
+  service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+
+  tests('success') do
+
+    server_id = nil
+    server_name = 'fog' + Time.now.to_i.to_s
+    image_id = '3afe97b2-26dc-49c5-a2cc-a2fc8d80c001' # Ubuntu 11.10
+    flavor_id = '2' # 512 MB
+
+    tests("#create_server(#{server_name}, #{image_id}, #{flavor_id}, 1, 1)").formats(CREATE_SERVER_FORMAT) do
+      body = service.create_server(server_name, image_id, flavor_id, 1, 1).body
+      server_id = body['server']['id']
+      body
+    end
+
+    tests('#list_servers').formats(LIST_SERVERS_FORMAT) do
+      service.list_servers.body
+    end
+
+    tests('#get_server').formats(GET_SERVER_FORMAT) do
+      service.get_server(server_id).body
+    end
+
+    until service.get_server(server_id).body['server']['status'] == 'ACTIVE'
+      sleep 10
+    end
+
+    tests("#update_server(#{server_id}, #{server_name}_update)").formats(GET_SERVER_FORMAT) do
+      service.update_server(server_id, "#{server_name}_update").body
+    end
+
+    tests('#change_server_password').succeeds do
+      service.change_server_password(server_id, 'some_server_password')
+    end
+
+    sleep 60
+
+    tests('#reboot_server').succeeds do
+      service.reboot_server(server_id, 'SOFT')
+    end
+
+    until service.get_server(server_id).body['server']['status'] == 'ACTIVE'
+      sleep 10
+    end
+
+    tests('#rebuild_server').succeeds do
+      rebuild_image_id = "5cebb13a-f783-4f8c-8058-c4182c724ccd" # Ubuntu 12.04
+      service.rebuild_server(server_id, rebuild_image_id)
+    end
+
+    until service.get_server(server_id).body['server']['status'] == 'ACTIVE'
+      sleep 10
+    end
+
+    tests('#resize_server').succeeds do
+      resize_flavor_id = 3 # 1GB
+      service.resize_server(server_id, resize_flavor_id)
+    end
+
+    until service.get_server(server_id).body['server']['status'] == 'VERIFY_RESIZE'
+      sleep 10
+    end
+
+    tests('#confirm_resize_server').succeeds do
+      service.confirm_resize_server(server_id)
+    end
+
+    until service.get_server(server_id).body['server']['status'] == 'ACTIVE'
+      sleep 10
+    end
+
+    tests('#resize_server').succeeds do
+      resize_flavor_id = 2 # 1GB
+      service.resize_server(server_id, resize_flavor_id)
+    end
+
+    until service.get_server(server_id).body['server']['status'] == 'VERIFY_RESIZE'
+      sleep 10
+    end
+
+    tests('#revert_resize_server').succeeds do
+      service.revert_resize_server(server_id)
+    end
+
+    until service.get_server(server_id).body['server']['status'] == 'ACTIVE'
+      sleep 10
+    end
+
+    tests('#delete_server').succeeds do
+      service.delete_server(server_id)
+    end
+  end
+end