fog-rackspace 0.1.0

data/tests/rackspace/models/auto_scale/groups_tests.rb

@@ -0,0 +1,17 @@
+Shindo.tests('Fog::Rackspace::AutoScale | groups', ['rackspace', 'rackspace_autoscale']) do
+  pending if Fog.mocking?
+  service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
+
+  options = {
+    :policies => POLICIES_OPTIONS,
+    :group_config => GROUP_CONFIG_OPTIONS,
+    :launch_config => LAUNCH_CONFIG_OPTIONS
+  }
+
+  collection_tests(service.groups, options, false) do
+    tests('deactive scaling group').succeeds do
+      deactive_auto_scale_group(@instance)
+    end
+  end
+
+end

data/tests/rackspace/models/auto_scale/policies_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests('Fog::Rackspace::AutoScale | policies', ['rackspace', 'rackspace_autoscale']) do
+  pending if Fog.mocking?
+  service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
+
+  begin
+    group = service.groups.create({
+      :policies => POLICIES_OPTIONS,
+      :group_config => GROUP_CONFIG_OPTIONS,
+      :launch_config => LAUNCH_CONFIG_OPTIONS
+    })
+
+    options = {
+      :name => "policy 2",
+      :change => 5,
+      :cooldown => 100,
+      :type => 'webhook'
+    }
+
+    collection_tests(group.policies, options, false)
+  ensure
+    deactive_auto_scale_group(group)
+    group.destroy if group
+  end
+end

data/tests/rackspace/models/auto_scale/policy_tests.rb

@@ -0,0 +1,35 @@
+Shindo.tests('Fog::Rackspace::AutoScale | policy', ['rackspace', 'rackspace_autoscale']) do
+
+  service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
+
+  pending if Fog.mocking?
+
+  begin
+    group = service.groups.create({
+      :policies => POLICIES_OPTIONS,
+      :group_config => GROUP_CONFIG_OPTIONS,
+      :launch_config => LAUNCH_CONFIG_OPTIONS
+    })
+
+    options = {
+      :name => "policy 2",
+      :change => 1,
+      :cooldown => 100,
+      :type => 'webhook',
+      :group => group
+    }
+
+    model_tests(group.policies, options, false) do
+      tests('#execute').succeeds do
+        @instance.execute
+      end
+      tests('#webhooks').succeeds do
+        @instance.webhooks
+      end
+    end
+  ensure
+    deactive_auto_scale_group(group)
+    group.destroy if group
+  end
+
+end

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

@@ -0,0 +1,42 @@
+Shindo.tests('Fog::Rackspace::AutoScale | webhook', ['rackspace', 'rackspace_autoscale']) do
+
+  service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
+
+  pending if Fog.mocking?
+
+  begin
+    group = service.groups.create({
+      :policies => POLICIES_OPTIONS,
+      :group_config => GROUP_CONFIG_OPTIONS,
+      :launch_config => LAUNCH_CONFIG_OPTIONS
+    })
+
+    policy = group.policies.create({
+      :name => "set group to 5 servers",
+      :desired_capacity => 5,
+      :cooldown => 1800,
+      :type => "webhook",
+      :group => group
+    })
+
+    options = {
+      :name => 'webhook name',
+      :metadata => {
+        'owner' => 'me'
+      },
+      :group => group,
+      :policy => policy
+    }
+
+    model_tests(policy.webhooks, options, false) do
+      tests('#execution_url').succeeds do
+        @instance.execution_url
+      end
+    end
+  ensure
+    policy.destroy if policy
+    deactive_auto_scale_group(group)
+    group.destroy if group
+  end
+
+end

data/tests/rackspace/models/auto_scale/webhooks_tests.rb

@@ -0,0 +1,28 @@
+Shindo.tests('Fog::Rackspace::AutoScale | webhooks', ['rackspace', 'rackspace_autoscale']) do
+  pending if Fog.mocking?
+  service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
+
+  begin
+    group = service.groups.create({
+      :policies => POLICIES_OPTIONS,
+      :group_config => GROUP_CONFIG_OPTIONS,
+      :launch_config => LAUNCH_CONFIG_OPTIONS
+    })
+
+    policy = group.policies.create({
+      :name => "policy 2",
+      :change => 5,
+      :cooldown => 100,
+      :type => 'webhook',
+      :group => group
+    })
+
+    options = {:name => 'New webhook', :group => group, :policy => policy }
+    collection_tests(policy.webhooks, options, false)
+  ensure
+    policy.destroy if policy
+    deactive_auto_scale_group(group)
+    group.destroy if group
+  end
+
+end

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

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Rackspace::BlockStorage | snapshot', ['rackspace']) do
+  service = Fog::Rackspace::BlockStorage.new
+
+  begin
+    volume = service.volumes.create({
+      :display_name => "fog_#{Time.now.to_i.to_s}",
+      :size => 100
+    })
+
+    volume.wait_for { ready? }
+
+    options = { :display_name => "fog_#{Time.now.to_i.to_s}", :volume_id => volume.id }
+    model_tests(service.snapshots, options, true) do
+      @instance.wait_for { ready? }
+
+      tests('double save').raises(Fog::Rackspace::BlockStorage::IdentifierTaken) do
+        @instance.save
+      end
+    end
+
+    volume.wait_for { snapshots.empty? }
+  ensure
+    volume.destroy if volume
+  end
+end

data/tests/rackspace/models/block_storage/snapshots_tests.rb

@@ -0,0 +1,18 @@
+Shindo.tests('Fog::Rackspace::BlockStorage | snapshots', ['rackspace']) do
+
+  service = Fog::Rackspace::BlockStorage.new
+  volume = service.volumes.create({
+    :display_name => "fog_#{Time.now.to_i.to_s}",
+    :size => 100
+  })
+
+  volume.wait_for { ready? }
+
+  options = { :display_name => "fog_#{Time.now.to_i.to_s}", :volume_id => volume.id }
+  collection_tests(service.snapshots, options, true) do
+    @instance.wait_for { ready? }
+  end
+
+  volume.wait_for { snapshots.empty? }
+  volume.destroy
+end

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

@@ -0,0 +1,31 @@
+Shindo.tests('Fog::Rackspace::BlockStorage | volume', ['rackspace']) do
+
+  service = Fog::Rackspace::BlockStorage.new
+  options = { :display_name => "fog_#{Time.now.to_i.to_s}", :size => 100 }
+
+  model_tests(service.volumes, options, true) do
+    @instance.wait_for{ ready? }
+
+    tests('double save').raises(Fog::Rackspace::BlockStorage::IdentifierTaken) do
+      @instance.save
+    end
+
+    tests('#attached?').succeeds do
+      @instance.state = 'in-use'
+      returns(true) { @instance.attached? }
+    end
+
+    tests('#snapshots').succeeds do
+      begin
+        snapshot = @instance.create_snapshot
+        snapshot.wait_for { ready? }
+
+        returns(true) { @instance.snapshots.first.id == snapshot.id }
+      ensure
+        snapshot.destroy if snapshot
+      end
+    end
+
+    @instance.wait_for { snapshots.empty? }
+  end
+end

data/tests/rackspace/models/block_storage/volume_types_tests.rb

@@ -0,0 +1,18 @@
+Shindo.tests('Fog::Rackspace::BlockStorage | volume_types', ['rackspace']) do
+
+  service = Fog::Rackspace::BlockStorage.new
+
+  tests("success") do
+    tests("#all").succeeds do
+      service.volume_types.all
+    end
+
+    tests("#get").succeeds do
+      service.volume_types.get(service.volume_types.first.id)
+    end
+  end
+
+  tests("failure").returns(nil) do
+    service.volume_types.get('some_random_identity')
+  end
+end

data/tests/rackspace/models/block_storage/volumes_tests.rb

@@ -0,0 +1,9 @@
+Shindo.tests('Fog::Rackspace::BlockStorage | volumes', ['rackspace']) do
+
+  service = Fog::Rackspace::BlockStorage.new
+  options = { :display_name => "fog_#{Time.now.to_i.to_s}", :size => 100 }
+
+  collection_tests(service.volumes, options, true) do
+    @instance.wait_for { ready? }
+  end
+end

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

@@ -0,0 +1,17 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | flavors', ['rackspace']) do
+  service = Fog::Compute::RackspaceV2.new
+
+  tests("success") do
+    tests("#all").succeeds do
+      service.flavors.all
+    end
+
+    tests("#get").succeeds do
+      service.flavors.get(service.flavors.first.id)
+    end
+  end
+
+  tests("failure").returns(nil) do
+    service.flavors.get(Fog::Rackspace::MockData::NOT_FOUND_ID)
+  end
+end

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

@@ -0,0 +1,74 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | image', ['rackspace']) do
+  service    = Fog::Compute::RackspaceV2.new
+
+  test_time = Time.now.to_i.to_s
+  options = {
+    :name => "fog_server_#{test_time}",
+    :flavor_id => rackspace_test_flavor_id(service),
+    :image_id => rackspace_test_image_id(service)
+  }
+
+  tests('ready?') do
+    @server = Fog::Compute::RackspaceV2::Image.new
+
+    tests('default in ready state').returns(true) do
+      @server.state = Fog::Compute::RackspaceV2::Image::ACTIVE
+      @server.ready?
+    end
+
+    tests('custom ready state').returns(true) do
+      @server.state = Fog::Compute::RackspaceV2::Image::SAVING
+      @server.ready?(Fog::Compute::RackspaceV2::Image::SAVING)
+    end
+
+    tests('default NOT in ready state').returns(false) do
+      @server.state = Fog::Compute::RackspaceV2::Image::SAVING
+      @server.ready?
+    end
+
+    tests('custom NOT ready state').returns(false) do
+      @server.state = Fog::Compute::RackspaceV2::Image::UNKNOWN
+      @server.ready?(Fog::Compute::RackspaceV2::Image::SAVING)
+    end
+
+    tests('default error state').returns(true) do
+      @server.state = Fog::Compute::RackspaceV2::Image::ERROR
+      exception_occurred = false
+      begin
+        @server.ready?
+      rescue Fog::Compute::RackspaceV2::InvalidImageStateException => e
+        exception_occurred = true
+        returns(true) {e.desired_state == Fog::Compute::RackspaceV2::Image::ACTIVE }
+        returns(true) {e.current_state == Fog::Compute::RackspaceV2::Image::ERROR }
+      end
+      exception_occurred
+    end
+
+    tests('custom error state').returns(true) do
+      @server.state = Fog::Compute::RackspaceV2::Image::UNKNOWN
+      exception_occurred = false
+      begin
+        @server.ready?(Fog::Compute::RackspaceV2::Image::SAVING, Fog::Compute::RackspaceV2::Image::UNKNOWN)
+      rescue Fog::Compute::RackspaceV2::InvalidImageStateException => e
+        exception_occurred = true
+        returns(true) {e.desired_state == Fog::Compute::RackspaceV2::Image::SAVING }
+        returns(true) {e.current_state == Fog::Compute::RackspaceV2::Image::UNKNOWN }
+      end
+      exception_occurred
+    end
+  end
+
+  tests("success") do
+    begin
+      server = service.servers.create(options)
+      server.wait_for { ready? }
+      image = server.create_image("fog_image_#{test_time}")
+
+      tests("destroy").succeeds do
+        image.destroy
+      end
+    ensure
+      server.destroy if server
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | images', ['rackspace']) do
+  service = Fog::Compute::RackspaceV2.new
+
+  image_id = nil
+
+  tests("success") do
+    tests("#all").succeeds do
+      images = service.images.all
+      image_id = images.first.id
+    end
+
+    tests("#get").succeeds do
+      service.images.get(image_id)
+    end
+  end
+
+  tests("failure").returns(nil) do
+    service.images.get(Fog::Rackspace::MockData::NOT_FOUND_ID)
+  end
+end

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

@@ -0,0 +1,47 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | key_pairs', ['rackspace']) do
+  service = Fog::Compute::RackspaceV2.new
+
+  name  = Fog::Mock.random_letters(32)
+  key   = nil
+
+  tests("API access") do
+    begin
+        tests("create").succeeds do
+          key = service.key_pairs.create({:name => name})
+        end
+
+        tests("list all").succeeds do
+          service.key_pairs.all
+        end
+
+        tests("get").succeeds do
+          service.key_pairs.get(name)
+        end
+
+        tests("delete").succeeds do
+          key = nil if service.key_pairs.destroy(name)
+          key == nil
+        end
+
+        tests("get unknown").returns(nil) do
+          service.key_pairs.get(Fog::Mock.random_letters(32))
+        end
+
+        tests("delete unknown").raises(Fog::Compute::RackspaceV2::NotFound) do
+            service.key_pairs.destroy(Fog::Mock.random_letters(32))
+        end
+
+        tests("create again after delete").succeeds do
+          key = service.key_pairs.create({:name => name})
+        end
+
+        tests("create already existing").raises(Fog::Compute::RackspaceV2::ServiceError) do
+          service.key_pairs.create({:name => name})
+        end
+
+    ensure
+        key.destroy if key
+    end
+
+  end
+end

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

@@ -0,0 +1,44 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | metadata', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  service = Fog::Compute::RackspaceV2.new
+  test_time = Time.now.to_i.to_s
+
+  tests('success') do
+    begin
+      @server = service.servers.create(:name => "fog_server_#{test_time}",
+      :flavor_id => rackspace_test_flavor_id(service),
+      :image_id => rackspace_test_image_id(service))
+
+      @server.wait_for { ready? }
+
+      tests('server') do
+        collection_tests(@server.metadata, {:key => 'my_key', :value => 'my_value'}) do
+          @server.wait_for { ready? }
+        end
+      end
+
+      tests('image') do
+        @image = @server.create_image("fog_image_#{test_time}", :metadata => {:my_key => 'my_value'})
+        @image.wait_for { ready? }
+        tests("#all").succeeds do
+          pending if Fog.mocking? && !mocks_implemented
+          metadata = @image.metadata.all
+          my_metadata = metadata.select {|datum| datum.key == 'my_key'}
+          returns(1) { my_metadata.size }
+          returns('my_value') {my_metadata[0].value }
+        end
+
+        tests("#get('my_key')").returns('my_value') do
+          pending if Fog.mocking? && !mocks_implemented
+          @image.metadata.get('my_key').value
+        end
+      end
+
+    ensure
+      @image.destroy if @image
+      @server.destroy if @server
+    end
+  end
+end