fog 0.8.2 → 0.9.0

data/tests/aws/models/rds/servers_tests.rb

@@ -0,0 +1,8 @@
+Shindo.tests("AWS::RDS | servers", ['aws', 'rds']) do
+
+  pending if Fog.mocking?
+
+  collection_tests(AWS[:rds].servers, rds_default_server_params, false) do
+    @instance.wait_for { ready? }
+  end
+end

data/tests/aws/models/rds/snapshot_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests("AWS::RDS | snapshot", ['aws', 'rds']) do
+
+  pending if Fog.mocking?
+
+  @server = AWS[:rds].servers.create(rds_default_server_params)
+  @server.wait_for { ready? }
+
+  params = {:id => uniq_id, :instance_id => @server.id}
+  model_tests(AWS[:rds].snapshots, params, false) do
+    @instance.wait_for { ready? }
+  end
+
+  @server.destroy
+end
+

data/tests/aws/models/rds/snapshots_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests("AWS::RDS | snapshots", ['aws', 'rds']) do
+
+  pending if Fog.mocking?
+
+  @server = AWS[:rds].servers.create(rds_default_server_params)
+  @server.wait_for { ready? }
+
+  params = {:id => uniq_id, :instance_id => @server.id}
+  collection_tests(AWS[:rds].snapshots, params, false) do
+    @instance.wait_for { ready? }
+  end
+
+  @server.destroy
+end
+

data/tests/aws/requests/cloud_formation/stack_tests.rb

@@ -85,7 +85,7 @@ Shindo.tests('AWS::CloudFormation | stack requests', ['aws', 'cloudformation'])
 
     unless Fog.mocking?
       @stack_name = 'fogstack' << Time.now.to_i.to_s
-      @keypair = AWS[:compute].key_pairs.create(:name => 'cloudformation')
+      @keypair = Compute[:aws].key_pairs.create(:name => 'cloudformation')
       @template_url = 'https://s3.amazonaws.com/cloudformation-templates-us-east-1/EC2InstanceSample-1.0.0.template'
     end
 

data/tests/aws/requests/elb/helper.rb

@@ -7,14 +7,17 @@ class AWS
       }
 
       LOAD_BALANCER = {
+        "AvailabilityZones" => Array,
+        "CanonicalHostedZoneName" => String,
+        "CanonicalHostedZoneNameID" => String,
         "CreatedTime" => Time,
-        "ListenerDescriptions" => Array,
+        "DNSName" => String,
         "HealthCheck" => {"HealthyThreshold" => Integer, "Timeout" => Integer, "UnhealthyThreshold" => Integer, "Interval" => Integer, "Target" => String},
+        "Instances" => Array,
+        "ListenerDescriptions" => Array,
+        "LoadBalancerName" => String,
         "Policies" => {"LBCookieStickinessPolicies" => Array, "AppCookieStickinessPolicies" => Array},
-        "AvailabilityZones" => Array,
-        "DNSName" => String,
-        "LoadBalancerName"=> String,
-        "Instances"=> Array
+        "SourceSecurityGroup" => {"GroupName" => String, "OwnerAlias" => String},
       }
 
       CREATE_LOAD_BALANCER = BASIC.merge({

data/tests/aws/requests/elb/model_tests.rb

@@ -16,7 +16,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
     tests('create') do
       elb = AWS[:elb].load_balancers.create(:id => elb_id)
       tests("dns names is set").returns(true) { elb.dns_name.is_a?(String) }
-      tests("created_at is set").returns(true) { (Time.now-10..Time.now).include? elb.created_at }
+      tests("created_at is set").returns(true) { Time === elb.created_at }
       tests("policies is empty").returns([]) { elb.policies }
     end
 
@@ -44,7 +44,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
       raises(Fog::AWS::ELB::InvalidInstance) { elb.deregister_instances('i-00000000') }
     end
 
-    server = AWS[:compute].servers.create
+    server = Compute[:aws].servers.create
     tests('register instance') do
       begin
         elb.register_instances(server.id)

data/tests/aws/requests/simpledb/attributes_tests.rb

@@ -36,14 +36,30 @@ Shindo.tests('AWS::SimpleDB | attributes requests', ['aws']) do
       AWS[:sdb].put_attributes(@domain_name, 'conditional', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version']).body
     end
 
+    # Verify that we can delete individual attributes.
+    tests("#delete_attributes('#{@domain_name}', 'a', {'d' => []})").succeeds do
+      AWS[:sdb].delete_attributes(@domain_name, 'a', {'d' => []}).body
+    end
+
+    # Verify that individually deleted attributes are actually removed.
+    tests("#get_attributes('#{@domain_name}', 'a', ['d']).body['Attributes']").returns({'d' => nil}) do
+      AWS[:sdb].get_attributes(@domain_name, 'a', ['d']).body['Attributes']
+    end
+
     tests("#delete_attributes('#{@domain_name}', 'a').body").formats(AWS::SimpleDB::Formats::BASIC) do
       AWS[:sdb].delete_attributes(@domain_name, 'a').body
     end
 
+    # Verify that we can delete entire domain, item combinations.
     tests("#delete_attributes('#{@domain_name}', 'a').body").succeeds do
       AWS[:sdb].delete_attributes(@domain_name, 'a').body
     end
 
+    # Verify that deleting a domain, item combination removes all related attributes.
+    tests("#get_attributes('#{@domain_name}', 'a').body['Attributes']").returns({}) do
+      AWS[:sdb].get_attributes(@domain_name, 'a').body['Attributes']
+    end
+
   end
 
   tests('failure') do

data/tests/compute/helper.rb

@@ -1,37 +1,40 @@
 def compute_providers
   {
-    AWS       => {
+    :aws        => {
       :server_attributes => {},
       :mocked => true
     },
-    Bluebox   => {
+    :bluebox    => {
       :server_attributes => {
         :image_id => '03807e08-a13d-44e4-b011-ebec7ef2c928', # Ubuntu 10.04 64bit
         :password => 'chunkybacon'
       },
       :mocked => false
     },
-    Brightbox => {
+    :brightbox  => {
       :server_attributes => {
         :image_id => 'img-2ab98' # Ubuntu Lucid 10.04 server (i686)
       },
       :mocked => false
     },
-    Rackspace => {
+    :ninefold   => {
+      :mocked => false
+    },
+    :rackspace  => {
       :server_attributes => {
         :image_id => 49, # image 49 = Ubuntu 10.04 LTS (lucid)
         :name     => "fog_#{Time.now.to_i}"
       },
       :mocked => true
     },
-    Slicehost => {
+    :slicehost  => {
       :server_attributes => {
         :image_id => 49, # image 49 = Ubuntu 10.04 LTS (lucid)
         :name     => "fog_#{Time.now.to_i}"
       },
       :mocked => false
     },
-    Voxel => {
+    :voxel      => {
       :server_attributes => {
         :name => "fog.#{Time.now.to_i}",
         :disk_size => 10,

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

@@ -1,8 +1,8 @@
-Shindo.tests("AWS::Compute | address", ['aws']) do
+Shindo.tests("Fog::Compute[:aws] | address", ['aws']) do
 
-  model_tests(AWS[:compute].addresses, {}, true) do
+  model_tests(Fog::Compute[:aws].addresses, {}, true) do
 
-    @server = AWS[:compute].servers.create
+    @server = Fog::Compute[:aws].servers.create
     @server.wait_for { ready? }
 
     tests('#server=').succeeds do

data/tests/compute/models/aws/addresses_tests.rb

@@ -1,5 +1,5 @@
-Shindo.tests("AWS::Compute | addresses", ['aws']) do
+Shindo.tests("Fog::Compute[:aws] | addresses", ['aws']) do
 
-  collection_tests(AWS[:compute].addresses, {}, true)
+  collection_tests(Fog::Compute[:aws].addresses, {}, true)
 
 end

data/tests/compute/models/aws/key_pair_tests.rb

@@ -1,13 +1,13 @@
-Shindo.tests("AWS::Compute | key_pair", ['aws']) do
+Shindo.tests("Fog::Compute[:aws] | key_pair", ['aws']) do
 
-  model_tests(AWS[:compute].key_pairs, {:name => 'fogkeyname'}, true)
+  model_tests(Fog::Compute[:aws].key_pairs, {:name => 'fogkeyname'}, true)
 
   after do
     @keypair.destroy
   end
 
   tests("new keypair") do
-    @keypair = AWS[:compute].key_pairs.create(:name => 'testkey')
+    @keypair = Fog::Compute[:aws].key_pairs.create(:name => 'testkey')
 
     test ("writable?") do
       @keypair.writable? == true
@@ -15,8 +15,8 @@ Shindo.tests("AWS::Compute | key_pair", ['aws']) do
   end
 
   tests("existing keypair") do
-    AWS[:compute].key_pairs.create(:name => 'testkey')
-    @keypair = AWS[:compute].key_pairs.get('testkey')
+    Fog::Compute[:aws].key_pairs.create(:name => 'testkey')
+    @keypair = Fog::Compute[:aws].key_pairs.get('testkey')
 
     test("writable?") do
       @keypair.writable? == false

data/tests/compute/models/aws/key_pairs_tests.rb

@@ -1,5 +1,5 @@
-Shindo.tests("AWS::Compute | key_pairs", ['aws']) do
+Shindo.tests("Fog::Compute[:aws] | key_pairs", ['aws']) do
 
-  collection_tests(AWS[:compute].key_pairs, {:name => 'fogkeyname'}, true)
+  collection_tests(Fog::Compute[:aws].key_pairs, {:name => 'fogkeyname'}, true)
 
 end

data/tests/compute/models/aws/security_group_tests.rb

@@ -1,9 +1,9 @@
-Shindo.tests("AWS::Compute | security_group", ['aws']) do
+Shindo.tests("Fog::Compute[:aws] | security_group", ['aws']) do
 
-  model_tests(AWS[:compute].security_groups, {:description => 'foggroupdescription', :name => 'foggroupname'}, true)
+  model_tests(Fog::Compute[:aws].security_groups, {:description => 'foggroupdescription', :name => 'foggroupname'}, true)
 
   tests("a group with trailing whitespace") do
-    @group = AWS[:compute].security_groups.create(:name => "foggroup with spaces   ", :description => "   fog group desc   ")
+    @group = Fog::Compute[:aws].security_groups.create(:name => "foggroup with spaces   ", :description => "   fog group desc   ")
     test("name is correct") do
       @group.name ==  "foggroup with spaces   "
     end

data/tests/compute/models/aws/security_groups.rb

@@ -1,5 +1,5 @@
-Shindo.tests("AWS::Compute | security_groups", ['aws']) do
+Shindo.tests("Fog::Compute[:aws] | security_groups", ['aws']) do
 
-  collection_tests(AWS[:compute].security_groups, {:description => 'foggroupdescription', :name => 'foggroupname'}, true)
+  collection_tests(Fog::Compute[:aws].security_groups, {:description => 'foggroupdescription', :name => 'foggroupname'}, true)
 
 end

data/tests/compute/models/aws/server_tests.rb

@@ -1,6 +1,6 @@
-Shindo.tests("AWS::Compute | monitor", ['aws']) do
+Shindo.tests("Fog::Compute[:aws] | monitor", ['aws']) do
 
-  @instance = AWS[:compute].servers.new
+  @instance = Fog::Compute[:aws].servers.new
 
   [:addresses, :flavor, :key_pair, :key_pair=, :volumes].each do |association|
     responds_to(association)

data/tests/compute/models/aws/snapshot_tests.rb

@@ -1,9 +1,9 @@
-Shindo.tests("AWS::Compute | snapshot", ['aws']) do
+Shindo.tests("Fog::Compute[:aws] | snapshot", ['aws']) do
 
-  @volume = AWS[:compute].volumes.create(:availability_zone => 'us-east-1a', :size => 1)
+  @volume = Fog::Compute[:aws].volumes.create(:availability_zone => 'us-east-1a', :size => 1)
   @volume.wait_for { ready? }
 
-  model_tests(AWS[:compute].snapshots, {:volume_id => @volume.identity}, true)
+  model_tests(Fog::Compute[:aws].snapshots, {:volume_id => @volume.identity}, true)
 
   @volume.destroy
 

data/tests/compute/models/aws/snapshots_tests.rb

@@ -1,10 +1,10 @@
-Shindo.tests("AWS::Compute | snapshots", ['aws']) do
+Shindo.tests("Fog::Compute[:aws] | snapshots", ['aws']) do
 
-  @volume = AWS[:compute].volumes.create(:availability_zone => 'us-east-1a', :size => 1)
+  @volume = Fog::Compute[:aws].volumes.create(:availability_zone => 'us-east-1a', :size => 1)
   @volume.wait_for { ready? }
 
-  collection_tests(AWS[:compute].snapshots, {:volume_id => @volume.identity}, true)
-                    
+  collection_tests(Fog::Compute[:aws].snapshots, {:volume_id => @volume.identity}, true)
+
   @volume.destroy
 
 end

data/tests/compute/models/aws/volume_tests.rb

@@ -1,9 +1,9 @@
-Shindo.tests("AWS::Compute | volume", ['aws']) do
+Shindo.tests("Fog::Compute[:aws] | volume", ['aws']) do
 
-  @server = AWS[:compute].servers.create
+  @server = Fog::Compute[:aws].servers.create
   @server.wait_for { ready? }
 
-  model_tests(AWS[:compute].volumes, {:availability_zone => @server.availability_zone, :size => 1, :device => '/dev/sdz1'}, true) do
+  model_tests(Fog::Compute[:aws].volumes, {:availability_zone => @server.availability_zone, :size => 1, :device => '/dev/sdz1'}, true) do
 
     @instance.wait_for { ready? }
 

data/tests/compute/models/aws/volumes_tests.rb

@@ -1,5 +1,5 @@
-Shindo.tests("AWS::Compute | volumes", ['aws']) do
+Shindo.tests("Fog::Compute[:aws] | volumes", ['aws']) do
 
-  collection_tests(AWS[:compute].volumes, {:availability_zone => 'us-east-1a', :size => 1, :device => '/dev/sdz1'}, true)
+  collection_tests(Fog::Compute[:aws].volumes, {:availability_zone => 'us-east-1a', :size => 1, :device => '/dev/sdz1'}, true)
 
 end

data/tests/compute/models/flavors_tests.rb

@@ -1,10 +1,10 @@
 for provider, config in compute_providers
 
-  next if [Voxel].include?(provider)
+  next if [:voxel].include?(provider)
 
-  Shindo.tests("#{provider}::Compute | flavors", [provider.to_s.downcase]) do
+  Shindo.tests("Fog::Compute[:#{provider}] | flavors", [provider]) do
 
-    flavors_tests(provider[:compute], (config[:flavors_attributes] || {}), config[:mocked])
+    flavors_tests(Fog::Compute[provider], (config[:flavors_attributes] || {}), config[:mocked])
 
   end
 

data/tests/compute/models/server_tests.rb

@@ -1,8 +1,8 @@
 for provider, config in compute_providers
 
-  Shindo.tests("#{provider}::Compute | server", [provider.to_s.downcase]) do
+  Shindo.tests("Fog::Compute[:#{provider}] | server", [provider]) do
 
-    server_tests(provider[:compute], (config[:server_attributes] || {}), config[:mocked]) do
+    server_tests(Fog::Compute[provider], (config[:server_attributes] || {}), config[:mocked]) do
 
       if Fog.mocking? && !config[:mocked]
         pending

data/tests/compute/models/servers_tests.rb

@@ -1,8 +1,8 @@
 for provider, config in compute_providers
 
-  Shindo.tests("#{provider}::Compute | servers", [provider.to_s.downcase]) do
+  Shindo.tests("Fog::Compute[:#{provider}] | servers", [provider]) do
 
-    servers_tests(provider[:compute], (config[:server_attributes] || {}), config[:mocked])
+    servers_tests(Fog::Compute[provider], (config[:server_attributes] || {}), config[:mocked])
 
   end
 

data/tests/compute/parsers/aws/monitor_unmonitor_instances_tests.rb

@@ -1,6 +1,6 @@
 require 'fog/compute/parsers/aws/monitor_unmonitor_instances'
 
-Shindo.tests('AWS::Compute::MonitorUnmonitorInstances | monitor/unmonitor parser') do
+Shindo.tests('Compute::AWS::MonitorUnmonitorInstances | monitor/unmonitor parser') do
 
   tests('success') do
 
@@ -26,7 +26,7 @@ Shindo.tests('AWS::Compute::MonitorUnmonitorInstances | monitor/unmonitor parser
         </UnmonitorInstancesResponse>
       AWS
 
-      parser = Fog::Parsers::AWS::Compute::MonitorUnmonitorInstances.new
+      parser = Fog::Parsers::Compute::AWS::MonitorUnmonitorInstances.new
       body = Nokogiri::XML::SAX::PushParser.new(parser)
       body << aws_result
 

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

@@ -1,4 +1,4 @@
-Shindo.tests('AWS::Compute | address requests', ['aws']) do
+Shindo.tests('Fog::Compute[:aws] | address requests', ['aws']) do
 
   @addresses_format = {
     'addressesSet' => [{
@@ -8,7 +8,7 @@ Shindo.tests('AWS::Compute | address requests', ['aws']) do
     'requestId' => String
   }
 
-  @server = AWS[:compute].servers.create
+  @server = Fog::Compute[:aws].servers.create
   @server.wait_for { ready? }
   @ip_address = @server.ip_address
 
@@ -17,54 +17,54 @@ Shindo.tests('AWS::Compute | address requests', ['aws']) do
     @public_ip = nil
 
     tests('#allocate_address').formats({'publicIp' => String, 'requestId' => String}) do
-      data = AWS[:compute].allocate_address.body
+      data = Fog::Compute[:aws].allocate_address.body
       @public_ip = data['publicIp']
       data
     end
 
     tests('#describe_addresses').formats(@addresses_format) do
-      AWS[:compute].describe_addresses.body
+      Fog::Compute[:aws].describe_addresses.body
     end
 
-    tests("#describe_addresses('public-ip' => #{@public_Ip}')").formats(@addresses_format) do
-      AWS[:compute].describe_addresses('public-ip' => @public_ip).body
+    tests("#describe_addresses('public-ip' => #{@public_ip}')").formats(@addresses_format) do
+      Fog::Compute[:aws].describe_addresses('public-ip' => @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
+    tests("#associate_addresses('#{@server.identity}', '#{@public_ip}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].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
+      Fog::Compute[:aws].disassociate_address(@public_ip).body
     end
 
     tests("#release_address('#{@public_ip}')").formats(AWS::Compute::Formats::BASIC) do
-      AWS[:compute].release_address(@public_ip).body
+      Fog::Compute[:aws].release_address(@public_ip).body
     end
 
   end
-  tests ('failure') do
+  tests('failure') do
 
-    @address = AWS[:compute].addresses.create
+    @address = Fog::Compute[:aws].addresses.create
 
-    tests("#associate_addresses('i-00000000', '#{@address.identity}')").raises(Fog::AWS::Compute::NotFound) do
-      AWS[:compute].associate_address('i-00000000', @address.identity)
+    tests("#associate_addresses('i-00000000', '#{@address.identity}')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].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')
+    tests("#associate_addresses('#{@server.identity}', '127.0.0.1')").raises(Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].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')
+    tests("#associate_addresses('i-00000000', '127.0.0.1')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].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')
+    tests("#disassociate_addresses('127.0.0.1') raises BadRequest error").raises(Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].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')
+    tests("#release_address('127.0.0.1')").raises(Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].release_address('127.0.0.1')
     end
 
     @address.destroy