fog-rackspace 0.1.0

data/tests/rackspace/requests/auto_scale/webhook_tests.rb

@@ -0,0 +1,58 @@
+Shindo.tests('Fog::Rackspace::AutoScale | webhook_tests', ['rackspace', 'rackspace_autoscale']) do
+  pending if Fog.mocking?
+  service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
+
+  begin
+    @group_id = service.create_group(LAUNCH_CONFIG_OPTIONS, GROUP_CONFIG_OPTIONS, POLICIES_OPTIONS).body['group']['id']
+    @policy_id = service.create_policy(@group_id, POLICY_OPTIONS).body['policies'][0]['id']
+
+    tests('success') do
+      tests('#create_webhook').formats(201) do
+        response = service.create_webhook(@group_id, @policy_id, WEBHOOK_OPTIONS)
+        @webhook_id = response.body['webhooks'][0]['id']
+        response.data[:status]
+      end
+
+      tests('#list_webhooks').formats(LIST_WEBHOOKS_FORMAT, false) do
+        response = service.list_webhooks(@group_id, @policy_id).body["webhooks"]
+      end
+
+      tests('#get_webhook').formats(WEBHOOK_FORMAT) do
+        response = service.get_webhook(@group_id, @policy_id, @webhook_id)
+        response.body['webhook']
+      end
+
+      tests('#update_webhook').formats(204) do
+        response = service.update_webhook(@group_id, @policy_id, @webhook_id, {'name' => 'new', 'metadata' => {}} )
+        response.data[:status]
+      end
+
+      tests('#delete_webhook').formats(204) do
+        response = service.delete_webhook(@group_id, @policy_id, @webhook_id)
+        response.data[:status]
+      end
+    end
+  ensure
+    service.delete_policy @group_id, @policy_id
+    service.delete_group @group_id
+  end
+
+  tests('failure') do
+    tests('#create_webhook').raises(Fog::Rackspace::AutoScale::BadRequest) do
+      service.create_webhook(@group_id, @policy_id, {})
+    end
+
+    tests('#get_webhook').raises(Fog::Rackspace::AutoScale::NotFound) do
+      service.get_webhook(@group_id, @policy_id, 123)
+    end
+
+    tests('#update_webhook').raises(Fog::Rackspace::AutoScale::BadRequest) do
+      service.update_webhook(@group_id, @policy_id, @webhook_id, {})
+    end
+
+    tests('#delete_webhook').raises(Fog::Rackspace::AutoScale::NotFound) do
+      service.delete_webhook(@group_id, @policy_id, 123)
+    end
+  end
+
+end

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

@@ -0,0 +1,80 @@
+Shindo.tests('Fog::Rackspace::BlockStorage | snapshot_tests', ['rackspace']) do
+  timeout = Fog.mocking? ? 1 : 10
+
+  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(100).body['volume']
+    volume_id = volume['id']
+    snapshot_id = nil
+
+    until service.get_volume(volume_id).body['volume']['status'] == 'available'
+      sleep timeout
+    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 timeout
+    end
+
+    tests("#delete_snapshot(#{snapshot_id})").succeeds do
+      service.delete_snapshot(snapshot_id)
+    end
+
+    until snapshot_deleted?(service, snapshot_id)
+      sleep timeout
+    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,75 @@
+Shindo.tests('Fog::Rackspace::BlockStorage | volume_tests', ['rackspace']) do
+
+  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,
+    'image_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
+    ids = []
+    size = 100
+
+    tests("#create_volume(#{size})").formats(get_volume_format) do
+      data = service.create_volume(size).body
+      ids << data['volume']['id']
+      data
+    end
+
+    tests("#create_volume for a bootable volume").formats(get_volume_format) do
+      # Find a suitable image.
+      image_id = rackspace_test_image_id(Fog::Compute.new(:provider => 'rackspace'))
+      data = service.create_volume(size, :image_id => image_id).body
+      tests("assigned an image id").returns(image_id) do
+        data['volume']['image_id']
+      end
+      ids << data['volume']['id']
+      data
+    end
+
+    tests("#list_volumes").formats(list_volume_format) do
+      service.list_volumes.body
+    end
+
+    tests("#get_volume(#{ids.first})").formats(get_volume_format) do
+      service.get_volume(ids.first).body
+    end
+
+    ids.each do |id|
+      tests("#delete_volume(#{id})").succeeds do
+        wait_for_volume_state(service, id, 'available')
+
+        service.delete_volume(id)
+      end
+    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,21 @@
+Shindo.tests('Fog::Rackspace::BlockStorage | volume_type_tests', ['rackspace']) do
+  volume_type_format = {
+    'name' => String,
+    'extra_specs' => Hash,
+    'id' => String
+  }
+
+  service = Fog::Rackspace::BlockStorage.new
+
+  tests('success') do
+    volume_type_id = service.volume_types.first.id
+
+    tests("#list_volume_types").formats('volume_types' => [volume_type_format]) do
+      service.list_volume_types.body
+    end
+
+    tests("#get_volume_type(#{volume_type_id})").formats('volume_type' => volume_type_format) do
+      service.get_volume_type(volume_type_id).body
+    end
+  end
+end

data/tests/rackspace/requests/cdn/cdn_tests.rb

@@ -0,0 +1,75 @@
+Shindo.tests('Fog::CDN[:rackspace] | CDN requests', ['rackspace']) do
+
+  @container_format = [String]
+
+  @containers_format = [{
+    "cdn_ios_uri" => String,
+    "log_retention" => Fog::Boolean,
+    "ttl" => Fixnum,
+    "cdn_streaming_uri" => String,
+    "cdn_enabled" => Fog::Boolean,
+    "name" => String,
+    "cdn_ssl_uri" => String,
+    "cdn_uri" => String
+  }]
+
+  @container_headers = {
+    "Content-Length" => String,
+    "X-Cdn-Enabled" => String,
+    "X-Log-Retention" => String,
+    "X-Cdn-Ios-Uri" => String,
+    "X-Ttl" => String,
+    "X-Cdn-Uri" => String,
+    "X-Cdn-Ssl-Uri" => String,
+    "X-Cdn-Streaming-Uri" => String,
+    "X-Trans-Id" => String,
+    "Date" => String
+  }
+
+  begin
+    unless Fog.mocking?
+      @directory = Fog::Storage[:rackspace].directories.create(:key => 'fogcontainertests')
+      @file = @directory.files.create(:key => 'fog_object', :body => lorem_file)
+    end
+
+    tests('success') do
+
+      tests("#put_container('fogcontainertests')").succeeds do
+        Fog::CDN[:rackspace].put_container('fogcontainertests', {'X-CDN-Enabled' => true })
+      end
+
+      tests("#get_containers").formats(@containers_format) do
+        Fog::CDN[:rackspace].get_containers.body
+      end
+
+      tests("#head_container('fogcontainertests')").formats(@container_headers) do
+        Fog::CDN[:rackspace].head_container('fogcontainertests').headers
+      end
+
+      tests("#post_container('fogcontainertests')").succeeds do
+        Fog::CDN[:rackspace].post_container('fogcontainertests', 'X-TTL' => 5000)
+      end
+
+      #NOTE: you are only allow 25 object purges per day. If this fails, you may be over the limit
+      tests("#delete_object('fog_object')").succeeds do
+        Fog::CDN[:rackspace].delete_object('fogcontainertests', 'fog_object')
+      end
+    end
+  ensure
+    unless Fog.mocking?
+      @file.destroy if @file
+      @directory.destroy if @directory
+    end
+  end
+
+  tests('failure') do
+
+    tests("#head_container('missing_container')").raises(Fog::Storage::Rackspace::NotFound) do
+      Fog::CDN[:rackspace].head_container('missing_container')
+    end
+
+    tests("#post_container('missing_container')").raises(Fog::Storage::Rackspace::NotFound) do
+      Fog::CDN[:rackspace].post_container('missing_container', 'X-TTL' => 5000)
+    end
+  end
+end

data/tests/rackspace/requests/compute/address_tests.rb

@@ -0,0 +1,42 @@
+Shindo.tests('Fog::Compute[:rackspace] | address requests', ['rackspace']) do
+
+  @service = Fog::Compute.new(:provider => :rackspace, :version => :v1)
+
+  tests('success') do
+
+    @server = @service.servers.create(:flavor_id => 1, :image_id => 19)
+
+    tests("#list_addresses(#{@server.id})").formats({'addresses' => {'private' => [String], 'public' => [String]}}) do
+      @service.list_addresses(@server.id).body
+    end
+
+    tests("#list_private_addresses(#{@server.id})").formats({'private' => [String]}) do
+      @service.list_private_addresses(@server.id).body
+    end
+
+    tests("#list_public_addresses(#{@server.id})").formats({'public' => [String]}) do
+      @service.list_public_addresses(@server.id).body
+    end
+
+    @server.wait_for { ready? }
+    @server.destroy
+
+  end
+
+  tests('failure') do
+
+    tests('#list_addresses(0)').raises(Fog::Compute::Rackspace::NotFound) do
+      @service.list_addresses(0)
+    end
+
+    tests('#list_private_addresses(0)').raises(Fog::Compute::Rackspace::NotFound) do
+      @service.list_private_addresses(0)
+    end
+
+    tests('#list_public_addresses(0)').raises(Fog::Compute::Rackspace::NotFound) do
+      @service.list_public_addresses(0)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,39 @@
+Shindo.tests('Fog::Compute[:rackspace] | flavor requests', ['rackspace']) do
+
+  @flavor_format = {
+    'disk'  => Integer,
+    'id'    => Integer,
+    'name'  => String,
+    'ram'   => Integer
+  }
+
+  @service = Fog::Compute.new(:provider => :rackspace, :version => :v1)
+
+  tests('success') do
+    tests('#get_flavor_details(1)').formats(@flavor_format) do
+      pending if Fog.mocking?
+       @service.get_flavor_details(1).body['flavor']
+    end
+
+    tests('#list_flavors').formats({'flavors' => [Rackspace::Compute::Formats::SUMMARY]}) do
+      pending if Fog.mocking?
+       @service.list_flavors.body
+    end
+
+    tests('#list_flavors_detail').formats({'flavors' => [@flavor_format]}) do
+      pending if Fog.mocking?
+       @service.list_flavors_detail.body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#get_flavor_details(0)').raises(Fog::Compute::Rackspace::NotFound) do
+      pending if Fog.mocking?
+       @service.get_flavor_details(0)
+    end
+
+  end
+
+end

data/tests/rackspace/requests/compute/helper.rb

@@ -0,0 +1,10 @@
+class Rackspace
+  module Compute
+    module Formats
+      SUMMARY = {
+        'id'    => Integer,
+        'name'  => String
+      }
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+Shindo.tests('Fog::Compute[:rackspace] | image requests', ['rackspace']) do
+
+  @image_format = {
+    'created'   => Fog::Nullable::String,
+    'id'        => Integer,
+    'name'      => String,
+    'progress'  => Fog::Nullable::Integer,
+    'serverId'  => Fog::Nullable::Integer,
+    'status'    => String,
+    'updated'   => String
+  }
+
+  @service = Fog::Compute.new(:provider => :rackspace, :version => :v1)
+
+  tests('success') do
+
+    @server =  @service.servers.create(:flavor_id => 1, :image_id => 19)
+    @server.wait_for { ready? }
+    @image_id = nil
+
+    tests("#create_image(#{@server.id})").formats(@image_format) do
+      data =  @service.create_image(@server.id).body['image']
+      @image_id = data['id']
+      data
+    end
+
+    unless Fog.mocking?
+       @service.images.get(@image_id).wait_for { ready? }
+    end
+
+    tests("#get_image_details(#{@image_id})").formats(@image_format) do
+      pending if Fog.mocking?
+       @service.get_image_details(@image_id).body['image']
+    end
+
+    tests('#list_images').formats({'images' => [Rackspace::Compute::Formats::SUMMARY]}) do
+       @service.list_images.body
+    end
+
+    tests('#list_images_detail').formats({'images' => [@image_format]}) do
+       @service.list_images_detail.body
+    end
+
+    unless Fog.mocking?
+       @service.images.get(@image_id).wait_for { ready? }
+    end
+
+    tests("#delete_image(#{@image_id})").succeeds do
+      pending if Fog.mocking? # because it will fail without the wait just above here, which won't work
+       @service.delete_image(@image_id)
+    end
+
+    @server.destroy
+
+  end
+
+  tests('failure') do
+
+    tests('#delete_image(0)').raises(Fog::Compute::Rackspace::NotFound) do
+       @service.delete_image(Fog::Rackspace::MockData::NOT_FOUND_ID)
+    end
+
+    tests('#get_image_details(0)').raises(Fog::Compute::Rackspace::NotFound) do
+      pending if Fog.mocking?
+       @service.get_image_details(Fog::Rackspace::MockData::NOT_FOUND_ID)
+    end
+
+  end
+
+end