fog 0.2.30 → 0.3.0

data/spec/rackspace/requests/storage/put_object_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe 'Rackspace::Storage.put_object' do
+  describe 'success' do
+
+    before(:each) do
+      Rackspace[:storage].put_container('container_name')
+    end
+
+    after(:each) do
+      Rackspace[:storage].delete_object('container_name', 'object_name')
+      Rackspace[:storage].delete_container('container_name')
+    end
+
+    it "should return proper attributes" do
+      Rackspace[:storage].put_object('container_name', 'object_name', lorem_file)
+    end
+
+  end
+end

data/spec/slicehost/models/compute/flavors_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/../../../shared_examples/flavors_examples'
+
+describe 'Fog::Slicehost::Compute::Flavors' do
+
+  it_should_behave_like "Flavors"
+
+  subject { @flavor = @flavors.all.first }
+
+  before(:each) do
+    @flavors = Slicehost[:compute].flavors
+  end
+
+end

data/spec/slicehost/models/{server_spec.rb → compute/server_spec.rb}

@@ -1,15 +1,15 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../shared_examples/server_examples'
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/../../../shared_examples/server_examples'
 
-describe 'Fog::Slicehost::Server' do
+describe 'Fog::Slicehost::Compute::Server' do
 
   it_should_behave_like "Server"
 
-  # flavor 1 = 256, image 3 = gentoo 2008.0
-  subject { @server = @servers.new(:flavor_id => 1, :image_id => 3, :name => Time.now.to_i.to_s) }
+  # flavor 1 = 256, image 49 = Ubuntu 10.04 LTS (lucid)
+  subject { @server = @servers.new(:flavor_id => 1, :image_id => 49, :name => Time.now.to_i.to_s) }
 
   before(:each) do
-    @servers = Slicehost[:slices].servers
+    @servers = Slicehost[:compute].servers
   end
 
   after(:each) do
@@ -36,8 +36,8 @@ describe 'Fog::Slicehost::Server' do
       })
       server.addresses.should == 'addresses'
       server.backup_id.should == 'backup_id'
-      server.bw_in.should == 'bw_in'
-      server.bw_out.should == 'bw_out'
+      server.bandwidth_in.should == 'bw_in'
+      server.bandwidth_out.should == 'bw_out'
       server.flavor_id.should == 'flavor_id'
       server.image_id.should == 'image_id'
       server.name.should == 'name'

data/spec/{rackspace/models/servers → slicehost/models/compute}/servers_spec.rb

@@ -1,15 +1,15 @@
 require File.dirname(__FILE__) + '/../../../spec_helper'
 require File.dirname(__FILE__) + '/../../../shared_examples/servers_examples'
 
-describe 'Fog::Rackspace::Servers::Servers' do
+describe 'Fog::Slicehost::Compute::Servers' do
 
   it_should_behave_like "Servers"
 
-  # flavor 1 = 256, image 3 = gentoo 2008.0
-  subject { @server = @servers.new(:flavor_id => 1, :image_id => 3, :name => 'name') }
+  # flavor 1 = 256, image 49 = Ubuntu 10.04 LTS (lucid)
+  subject { @server = @servers.new(:flavor_id => 1, :image_id => 49, :name => Time.now.to_i.to_s) }
 
   before(:each) do
-    @servers = Rackspace[:servers].servers
+    @servers = Slicehost[:compute].servers
   end
 
   after(:each) do

data/spec/spec_helper.rb

@@ -16,14 +16,14 @@ module AWS
           ![:aws_access_key_id, :aws_secret_access_key].include?(k)
         end
         hash[key] = case key
-        when :ec2
-          Fog::AWS::EC2.new(credentials)
-        when :eu_s3
-          Fog::AWS::S3.new(credentials.merge!(:host => 's3-external-3.amazonaws.com'))
+        when :compute
+          Fog::AWS::Compute.new(credentials)
+        when :eu_storage
+          Fog::AWS::Storage.new(credentials.merge!(:host => 's3-external-3.amazonaws.com'))
         when :sdb
           Fog::AWS::SimpleDB.new(credentials)
-        when :s3
-          Fog::AWS::S3.new(credentials)
+        when :storage
+          Fog::AWS::Storage.new(credentials)
         end
       end
       @@connections[service]
@@ -39,10 +39,10 @@ module Rackspace
           ![:rackspace_api_key, :rackspace_username].include?(k)
         end
         hash[key] = case key
-        when :files
-          Fog::Rackspace::Files.new(credentials)
-        when :servers
-          Fog::Rackspace::Servers.new(credentials)
+        when :compute
+          Fog::Rackspace::Compute.new(credentials)
+        when :storage
+          Fog::Rackspace::Storage.new(credentials)
         end
       end
       @@connections[service]
@@ -58,8 +58,8 @@ module Slicehost
           ![:slicehost_password].include?(k)
         end
         hash[key] = case key
-        when :slices
-          Fog::Slicehost.new(credentials)
+        when :compute
+          Fog::Slicehost::Compute.new(credentials)
         end
       end
       @@connections[service]
@@ -75,8 +75,8 @@ module Bluebox
           ![:bluebox_api_key, :bluebox_customer_id].include?(k)
         end
         hash[key] = case key
-        when :blocks
-          Fog::Bluebox.new(credentials)
+        when :compute
+          Fog::Bluebox::Compute.new(credentials)
         end
       end
       @@connections[service]

data/spec/vcloud/models/vdc_spec.rb

@@ -21,7 +21,7 @@ if Fog.mocking?
     end
 
     context "as a collection member" do
-      subject { @vcloud.vdcs[0].reload; @vcloud.vdcs[0] }
+      subject { p @vcloud.vdcs[0]; @vcloud.vdcs[0].reload; @vcloud.vdcs[0] }
 
       it { should be_an_instance_of Fog::Vcloud::Vdc }
 

data/spec/vcloud/spec_helper.rb

@@ -234,12 +234,9 @@ Spec::Runner.configure do |config|
   end
 
   config.before(:each, :type => :vcloud_request) do
-    @vcloud = Fog.services.detect { |service| service == Vcloud }[:vcloud]
+    @vcloud = Fog::Vcloud::Terremark::Ecloud.new(Fog.credentials[:vcloud][:ecloud])
   end
 
-  config.before(:all, :type => :mock_vcloud_model) do
-    @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions")
-  end
   config.before(:all, :type => :mock_vcloud_model) do
     @base_url = Fog::Vcloud::Mock.base_url
     @mock_data = Fog::Vcloud::Mock.data
@@ -256,20 +253,23 @@ Spec::Runner.configure do |config|
     @mock_vdc = @mock_organization[:vdcs][0]
     @mock_network = @mock_vdc[:networks][0]
   end
+  config.before(:all, :type => :mock_vcloud_model) do
+    @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions")
+  end
   config.before(:each, :type => :mock_vcloud_request) do
-    @vcloud = Fog::Vcloud.new(:username => "", :password => "bar", :versions_uri => "http://fakey.com/api/versions")
+    @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions")
   end
   config.before(:each, :type => :mock_tmrk_ecloud_request) do
     Fog::Vcloud::Mock.data_reset
     Fog::Vcloud::Terremark::Ecloud::Mock.data_reset
     setup_ecloud_mock_data
-    @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions", :module => "Fog::Vcloud::Terremark::Ecloud")
+    @vcloud = Fog::Vcloud::Terremark::Ecloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions", :module => "Fog::Vcloud::Terremark::Ecloud")
   end
   config.before(:each, :type => :mock_tmrk_ecloud_model) do
     Fog::Vcloud::Mock.data_reset
     Fog::Vcloud::Terremark::Ecloud::Mock.data_reset
     setup_ecloud_mock_data
-    @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions", :module => "Fog::Vcloud::Terremark::Ecloud")
+    @vcloud = Fog::Vcloud::Terremark::Ecloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions", :module => "Fog::Vcloud::Terremark::Ecloud")
   end
 end
 

data/spec/vcloud/terremark/ecloud/models/internet_service_spec.rb

@@ -46,7 +46,7 @@ if Fog.mocking?
       its(:public_ip)             { should == public_ip }
       its(:timeout)               { should == @mock_service[:timeout] }
       its(:redirect_url)          { should == @mock_service[:redirect_url] }
-      its(:monitor)               { should == "" }
+      its(:monitor)               { should == nil }
 
       specify { composed_public_ip_data[:href].should == public_ip[:Href].to_s }
       specify { composed_public_ip_data[:name].should == public_ip[:Name] }

data/tests/aws/helper.rb

@@ -7,21 +7,21 @@ module AWS
           ![:aws_access_key_id, :aws_secret_access_key].include?(k)
         end
         hash[key] = case key
-        when :ec2
-          Fog::AWS::EC2.new(credentials)
-        when :eu_s3
-          Fog::AWS::S3.new(credentials.merge!(:host => 's3-external-3.amazonaws.com'))
+        when :compute
+          Fog::AWS::Compute.new(credentials)
+        when :eu_storage
+          Fog::AWS::Storage.new(credentials.merge!(:host => 's3-external-3.amazonaws.com'))
         when :sdb
           Fog::AWS::SimpleDB.new(credentials)
-        when :s3
-          Fog::AWS::S3.new(credentials)
+        when :storage
+          Fog::AWS::Storage.new(credentials)
         end
       end
       @@connections[service]
     end
   end
 
-  module EC2
+  module Compute
 
     module Formats
 
@@ -38,4 +38,4 @@ end
 
 unless defined?(GENTOO_AMI)
   GENTOO_AMI = 'ami-5ee70037'
-end
+end

data/tests/aws/models/storage/directory_tests.rb

@@ -0,0 +1,8 @@
+Shindo.tests('AWS::Storage | directory models', ['aws']) do
+
+  @collection = AWS[:storage].directories
+  @model = @collection.new(:key => Time.now.to_f.to_s)
+
+  tests_models
+
+end

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

@@ -0,0 +1,80 @@
+Shindo.tests('AWS::Compute | address requests', ['aws']) do
+
+  @addresses_format = {
+    'addressesSet' => [{
+      'instanceId'  => NilClass,
+      'publicIp'    => String
+    }],
+    'requestId' => String
+  }
+
+  @server = AWS[:compute].servers.create(:image_id => GENTOO_AMI)
+  @server.wait_for { ready? }
+  @ip_address = @server.ip_address
+
+  tests('success') do
+
+    @public_ip = nil
+
+    tests('#allocate_address').formats({'publicIp' => String, 'requestId' => String}) do
+      data = AWS[:compute].allocate_address.body
+      @public_ip = data['publicIp']
+      data
+    end
+
+    tests('#describe_addresses').formats(@addresses_format) do
+      AWS[:compute].describe_addresses.body
+    end
+
+    tests("#describe_addresses('#{@public_Ip}')").formats(@addresses_format) do
+      AWS[:compute].describe_addresses(@public_ip).body
+    end
+
+    tests("#associate_addresses('#{@server.identity}', '#{@public_Ip}')").formats(AWS::Compute::Formats::BASIC) do
+      AWS[:compute].associate_address(@server.identity, @public_ip).body
+    end
+
+    tests("#dissassociate_address('#{@public_ip}')").formats(AWS::Compute::Formats::BASIC) do
+      AWS[:compute].disassociate_address(@public_ip).body
+    end
+
+    tests("#release_address('#{@public_ip}')").formats(AWS::Compute::Formats::BASIC) do
+      AWS[:compute].release_address(@public_ip).body
+    end
+
+  end
+  tests ('failure') do
+
+    @address = AWS[:compute].addresses.create
+
+    tests("#describe_addresses('127.0.0.1')").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].describe_addresses('127.0.0.1')
+    end
+
+    tests("#associate_addresses('i-00000000', '#{@address.identity}')").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].associate_address('i-00000000', @address.identity)
+    end
+
+    tests("#associate_addresses('#{@server.identity}', '127.0.0.1')").raises(Fog::AWS::Compute::Error) do
+      AWS[:compute].associate_address(@server.identity, '127.0.0.1')
+    end
+
+    tests("#associate_addresses('i-00000000', '127.0.0.1')").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].associate_address('i-00000000', '127.0.0.1')
+    end
+
+    tests("#disassociate_addresses('127.0.0.1') raises BadRequest error").raises(Fog::AWS::Compute::Error) do
+      AWS[:compute].disassociate_address('127.0.0.1')
+    end
+
+    tests("#release_address('127.0.0.1')").raises(Fog::AWS::Compute::Error) do
+      AWS[:compute].release_address('127.0.0.1')
+    end
+
+    @address.destroy
+
+  end
+
+  @server.destroy
+
+end

data/tests/aws/requests/{ec2 → compute}/availability_zone_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests('AWS::EC2 | availability zone requests', ['aws']) do
+Shindo.tests('AWS::Compute | availability zone requests', ['aws']) do
 
   @availability_zones_format = {
     'availabilityZoneInfo'  => [{
@@ -12,19 +12,19 @@ Shindo.tests('AWS::EC2 | availability zone requests', ['aws']) do
   tests('success') do
 
     tests('#describe_availability_zones').formats(@availability_zones_format) do
-      AWS[:ec2].describe_availability_zones.body
+      AWS[:compute].describe_availability_zones.body
     end
 
     tests("#describe_availability_zones('us-east-1a')").formats(@availability_zones_format) do
-      AWS[:ec2].describe_availability_zones('us-east-1a').body
+      AWS[:compute].describe_availability_zones('us-east-1a').body
     end
 
   end
 
   tests('failure') do
 
-    tests("#describe_availability_zones('us-east-1e')").raises(Fog::AWS::EC2::Error) do
-      AWS[:ec2].describe_availability_zones('us-east-1e')
+    tests("#describe_availability_zones('us-east-1e')").raises(Fog::AWS::Compute::Error) do
+      AWS[:compute].describe_availability_zones('us-east-1e')
     end
 
   end

data/tests/aws/requests/{ec2 → compute}/instance_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests('AWS::EC2 | instance requests', ['aws']) do
+Shindo.tests('AWS::Compute | instance requests', ['aws']) do
 
   @instance_format = {
     # 'architecture'    => String,
@@ -69,52 +69,52 @@ Shindo.tests('AWS::EC2 | instance requests', ['aws']) do
     @instance_id = nil
 
     tests("#run_instances('#{GENTOO_AMI}', 1, 1)").formats(@run_instances_format) do
-      data = AWS[:ec2].run_instances(GENTOO_AMI, 1, 1).body
+      data = AWS[:compute].run_instances(GENTOO_AMI, 1, 1).body
       @instance_id = data['instancesSet'].first['instanceId']
       data
     end
 
-    AWS[:ec2].servers.get(@instance_id).wait_for { ready? }
+    AWS[:compute].servers.get(@instance_id).wait_for { ready? }
 
     # The format changes depending on state of instance, so this would be brittle
     # tests("#describe_instances").formats(@describe_instances_format) do
-    #   AWS[:ec2].describe_instances.body
+    #   AWS[:compute].describe_instances.body
     # end
 
     tests("#describe_instances('#{@instance_id}')").formats(@describe_instances_format) do
-      AWS[:ec2].describe_instances(@instance_id).body
+      AWS[:compute].describe_instances(@instance_id).body
     end
 
     tests("#get_console_output('#{@instance_id}')").formats(@get_console_output_format) do
-      AWS[:ec2].get_console_output(@instance_id).body
+      AWS[:compute].get_console_output(@instance_id).body
     end
 
-    tests("#reboot_instances('#{@instance_id}')").formats(AWS::EC2::Formats::BASIC) do
-      AWS[:ec2].reboot_instances(@instance_id).body
+    tests("#reboot_instances('#{@instance_id}')").formats(AWS::Compute::Formats::BASIC) do
+      AWS[:compute].reboot_instances(@instance_id).body
     end
 
     tests("#terminate_instances('#{@instance_id}')").formats(@terminate_instances_format) do
-      AWS[:ec2].terminate_instances(@instance_id).body
+      AWS[:compute].terminate_instances(@instance_id).body
     end
 
   end
 
   tests('failure') do
 
-    tests("#describe_instances('i-00000000')").raises(Fog::AWS::EC2::NotFound) do
-      AWS[:ec2].describe_instances('i-00000000')
+    tests("#describe_instances('i-00000000')").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].describe_instances('i-00000000')
     end
 
-    tests("#get_console_output('i-00000000')").raises(Fog::AWS::EC2::NotFound) do
-      AWS[:ec2].get_console_output('i-00000000')
+    tests("#get_console_output('i-00000000')").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].get_console_output('i-00000000')
     end
 
-    tests("#reboot_instances('i-00000000')").raises(Fog::AWS::EC2::NotFound) do
-      AWS[:ec2].reboot_instances('i-00000000')
+    tests("#reboot_instances('i-00000000')").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].reboot_instances('i-00000000')
     end
 
-    tests("#terminate_instances('i-00000000')").raises(Fog::AWS::EC2::NotFound) do
-      AWS[:ec2].terminate_instances('i-00000000')
+    tests("#terminate_instances('i-00000000')").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].terminate_instances('i-00000000')
     end
 
   end

data/tests/aws/requests/{ec2 → compute}/key_pair_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests('AWS::EC2 | key pair requests', ['aws']) do
+Shindo.tests('AWS::Compute | key pair requests', ['aws']) do
 
   tests('success') do
 
@@ -20,36 +20,36 @@ Shindo.tests('AWS::EC2 | key pair requests', ['aws']) do
     @key_pair_name = 'fog_key_pair'
 
     tests("#create_key_pair('#{@key_pair_name}')").formats(@keypair_format) do
-      AWS[:ec2].create_key_pair(@key_pair_name).body
+      AWS[:compute].create_key_pair(@key_pair_name).body
     end
 
     tests('#describe_key_pairs').formats(@keypairs_format) do
-      AWS[:ec2].describe_key_pairs.body
+      AWS[:compute].describe_key_pairs.body
     end
 
     tests("#describe_key_pairs(#{@key_pair_name})").formats(@keypairs_format) do
-      AWS[:ec2].describe_key_pairs(@key_pair_name).body
+      AWS[:compute].describe_key_pairs(@key_pair_name).body
     end
 
-    tests("#delete_key_pair('#{@key_pair_name}')").formats(AWS::EC2::Formats::BASIC) do
-      AWS[:ec2].delete_key_pair(@key_pair_name).body
+    tests("#delete_key_pair('#{@key_pair_name}')").formats(AWS::Compute::Formats::BASIC) do
+      AWS[:compute].delete_key_pair(@key_pair_name).body
     end
 
     tests("#delete_key_pair('not_a_key_name')").succeeds do
-      AWS[:ec2].delete_key_pair('not_a_key_name')
+      AWS[:compute].delete_key_pair('not_a_key_name')
     end
 
   end
   tests('failure') do
 
-    @key_pair = AWS[:ec2].key_pairs.create(:name => 'fog_key_pair')
+    @key_pair = AWS[:compute].key_pairs.create(:name => 'fog_key_pair')
 
-    tests("duplicate #create_key_pair('#{@key_pair.name}')").raises(Fog::AWS::EC2::Error) do
-      AWS[:ec2].create_key_pair(@key_pair.name)
+    tests("duplicate #create_key_pair('#{@key_pair.name}')").raises(Fog::AWS::Compute::Error) do
+      AWS[:compute].create_key_pair(@key_pair.name)
     end
 
-    tests("#describe_key_pair('not_a_key_name')").raises(Fog::AWS::EC2::NotFound) do
-      AWS[:ec2].describe_key_pairs('not_a_key_name').body
+    tests("#describe_key_pair('not_a_key_name')").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].describe_key_pairs('not_a_key_name').body
     end
 
     @key_pair.destroy