fog 1.9.0 → 1.10.0

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

@@ -7,7 +7,10 @@ Shindo.tests('Fog::Compute::RackspaceV2 | metadata', ['rackspace']) do
   
   tests('success') do
     begin
-      @server = service.servers.create(:name => "fog_server_#{test_time}", :flavor_id => 2, :image_id => "3afe97b2-26dc-49c5-a2cc-a2fc8d80c001")
+      @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(timeout=1500) { ready? }
       
       tests('server') do
@@ -17,8 +20,7 @@ Shindo.tests('Fog::Compute::RackspaceV2 | metadata', ['rackspace']) do
       end
       
       tests('image') do
-        image_id = @server.create_image("fog_image_#{test_time}", :metadata => {:my_key => 'my_value'})
-        @image = service.images.get image_id
+        @image = @server.create_image("fog_image_#{test_time}", :metadata => {:my_key => 'my_value'})
         @image.wait_for(timeout = 1500) { ready? }
         tests("#all").succeeds do
           pending if Fog.mocking? && !mocks_implemented

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

@@ -0,0 +1,10 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | network', ['rackspace']) do
+  service = Fog::Compute::RackspaceV2.new
+
+  options = {
+    :label => "fog_network_#{Time.now.to_i.to_s}",
+    :cidr => '192.168.0.0/24'
+  }
+
+  model_tests(service.networks, options, true)
+end

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

@@ -0,0 +1,10 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | networks', ['rackspace']) do
+  service = Fog::Compute::RackspaceV2.new
+
+  options = {
+    :label => "fog_network_#{Time.now.to_i.to_s}",
+    :cidr => '192.168.0.0/24'
+  }
+
+  collection_tests(service.networks, options, true)
+end

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

@@ -2,19 +2,20 @@ Shindo.tests('Fog::Compute::RackspaceV2 | server', ['rackspace']) do
   service = Fog::Compute::RackspaceV2.new
   cbs_service = Fog::Rackspace::BlockStorage.new
 
-  flavor_id  = Fog.credentials[:rackspace_flavor_id] || service.flavors.first.id
-  image_id   = Fog.credentials[:rackspace_image_id]  || service.images.first.id
-  image_id ||= Fog.mocking? ? service.images.first.id : service.images.find {|image| image.name =~ /Ubuntu/}.id # use the first Ubuntu image
-
   options = {
     :name => "fog_server_#{Time.now.to_i.to_s}",
-    :flavor_id => flavor_id,
-    :image_id => image_id
+    :flavor_id => rackspace_test_flavor_id(service),
+    :image_id => rackspace_test_image_id(service), 
+    :metadata => { 'fog_test' => 'true' }
   }
 
   model_tests(service.servers, options, true) do
     @instance.wait_for(timeout=1500) { ready? }
     
+    tests('#metadata[\'fog_test\']').returns('true') do
+      @instance.metadata['fog_test']
+    end
+    
     tests('#update').succeeds do
       @instance.name = "fog_server_update"
       @instance.access_ipv4_address= "10.10.0.1"
@@ -54,7 +55,7 @@ Shindo.tests('Fog::Compute::RackspaceV2 | server', ['rackspace']) do
     @instance.wait_for(timeout=1500) { ready? }
     sleep 60  unless Fog.mocking?
     tests('#rebuild').succeeds do
-      @instance.rebuild(image_id)
+      @instance.rebuild rackspace_test_image_id(service)
       returns('REBUILD') { @instance.state }
     end
 

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

@@ -1,20 +1,18 @@
 Shindo.tests('Fog::Compute::RackspaceV2 | servers', ['rackspace']) do
-  connection = Fog::Compute::RackspaceV2.new
-  flavor_id     = Fog.credentials[:rackspace_flavor_id] || connection.flavors.first.id
-  image_id      = Fog.credentials[:rackspace_image_id]  || connection.images.first.id
+  service = Fog::Compute::RackspaceV2.new
 
   options = {
     :name => "fog_server_#{Time.now.to_i.to_s}",
-    :flavor_id => flavor_id,
-    :image_id => image_id
+    :flavor_id => rackspace_test_flavor_id(service),
+    :image_id => rackspace_test_image_id(service)
   }
-  collection_tests(connection.servers, options, true) do
+  collection_tests(service.servers, options, true) do
     @instance.wait_for { ready? }
   end
 
   tests("#bootstrap").succeeds do
     pending if Fog.mocking?
-    @server = connection.servers.bootstrap(options)
+    @server = service.servers.bootstrap(options)
   end
 
   if @server

data/tests/rackspace/models/dns/zones_tests.rb

@@ -0,0 +1,22 @@
+Shindo.tests('Fog::Rackspace::DNS | zones', ['rackspace']) do
+  pending if Fog.mocking?
+
+  provider = Fog::DNS[:rackspace]
+  domain_sld = uniq_id
+  domain_name = domain_sld + '.com'
+
+  begin
+    zone = provider.zones.create({:domain => domain_name, :email => "hostmaster@#{domain_name}"})
+
+    tests("zones.find(#{domain_sld}) => finds domain_name") do
+      returns(1) { provider.zones.find(domain_sld).length }
+    end
+
+    random_name = uniq_id
+    tests("zones.find(#{random_name}) => finds nothing") do
+      returns(0) { provider.zones.find(random_name).length }
+    end
+  ensure
+    zone.destroy
+  end
+end

data/tests/rackspace/models/identity/credentials_tests.rb

@@ -5,12 +5,21 @@ Shindo.tests('Fog::Rackspace::Identity | credentials', ['rackspace']) do
   service = Fog::Rackspace::Identity.new
   user = service.users.all.first
 
-  tests("#all").succeeds do
-    user.credentials.all
+  tests('success') do
+    tests("#all").succeeds do
+      credentials = user.credentials.all
+      credentials.all? { |c| c.username && c.apiKey }
+    end
+
+    tests("#get").succeeds do
+      list_credential = user.credentials.all.first
+
+      credential = user.credentials.get(list_credential.identity)
+      credential.username && credential.apiKey
+    end
   end
 
-  tests("#get").succeeds do
-    credential = user.credentials.all.first
-    user.credentials.get(credential.identity)
+  tests("failure").returns(nil) do
+    user.credentials.get('i am a credential that does not exist')
   end
 end

data/tests/rackspace/models/storage/account_tests.rb

@@ -0,0 +1,28 @@
+Shindo.tests('Fog::Rackspace::Storage | account', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  @account = Fog::Storage[:rackspace].account
+
+  tests('load') do
+    headers = @account.service.head_containers.headers
+
+    returns(headers['X-Account-Meta-Temp-Url-Key']) { @account.meta_temp_url_key }
+    returns(headers['X-Account-Container-Count'].to_i) { @account.container_count }
+    returns(headers['X-Account-Bytes-Used'].to_i) { @account.bytes_used }
+    returns(headers['X-Account-Object-Count'].to_i) { @account.object_count }
+  end
+
+  tests('reload') do
+    @account.reload
+  end
+
+  tests('save') do
+    key = "testing-update-#{Time.now.to_i}"
+    @account.meta_temp_url_key = "testing-update-#{Time.now.to_i}"
+    @account.save
+    
+    headers = @account.service.head_containers.headers
+    returns(key) { headers['X-Account-Meta-Temp-Url-Key'] }
+  end
+end

data/tests/rackspace/models/storage/directories_tests.rb

@@ -0,0 +1,29 @@
+Shindo.tests('Fog::Rackspace::Storage | directories', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  @service = Fog::Storage[:rackspace]
+
+
+  begin
+    @name = "fog-directories-test-#{Time.now.to_i.to_s}"
+    @filename = 'lorem.txt'    
+    @dir = @service.directories.create :key => @name, :metadata => {:fog_test => true}
+    @file = @dir.files.create :key => @filename, :body => lorem_file
+
+    tests('#get').succeeds do
+      instance = @service.directories.get @name
+      returns(false) { instance.nil? }
+      returns('true') { instance.metadata[:fog_test] }
+      returns(@name) { instance.key }
+      returns(1) { instance.count }
+      returns( Fog::Storage.get_body_size(lorem_file)) {instance.bytes }
+      returns(@filename) { instance.files.first.key }
+    end
+    
+  ensure
+    @file.destroy if @file
+    @dir.destroy if @dir
+  end
+   
+end

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

@@ -0,0 +1,141 @@
+Shindo.tests('Fog::Rackspace::Storage | directory', ['rackspace']) do
+
+  pending if Fog.mocking?
+
+  @service = Fog::Storage[:rackspace]
+  
+  def container_meta_attributes
+    @service.head_container(@instance.key).headers.reject {|k, v| !(k =~ /X-Container-Meta-/)}
+  end
+  
+  directory_attributes = {
+    # Add a random suffix to prevent collision
+    :key => "fog-directory-tests-#{rand(65536)}"
+  }
+  
+   model_tests(@service.directories, directory_attributes, Fog.mocking?) do
+     
+     tests('#public?').returns(false) do
+       @instance.public?
+     end
+     
+     tests('#public_url') do
+       
+       tests('http').returns(nil) do
+         @instance.public_url
+        end
+
+        @instance.cdn_cname = "my_cname.com"        
+        tests('cdn_cname').returns(nil) do
+          @instance.public_url
+        end
+        
+        @instance.cdn_cname = nil
+        @service.instance_variable_set "@rackspace_cdn_ssl", true
+        tests('ssl').returns(nil) do
+          @instance.public_url
+        end   
+        @service.instance_variable_set "@rackspace_cdn_ssl", nil             
+     end
+     
+     tests('#ios_url').returns(nil) do
+       @instance.ios_url
+     end
+
+     tests('#streaming_url').returns(nil) do
+       @instance.streaming_url
+     end
+     
+     tests('cdn') do
+       @instance.public = true
+       @instance.save
+       
+       tests('#public?').returns(true) do
+         @instance.public?
+       end
+
+       tests('#public_url') do
+
+         tests('http').returns(0) do
+           @instance.public_url  =~ /http:\/\//
+          end
+
+          @instance.cdn_cname = "my_cname.com"        
+          tests('cdn_cname').returns(0) do
+            @instance.public_url  =~ /my_cname\.com/
+          end
+
+          @instance.cdn_cname = nil
+          @service.instance_variable_set "@rackspace_cdn_ssl", true
+          tests('ssl').returns(0) do
+            @instance.public_url =~ /https:\/\/.+\.ssl\./
+          end   
+          @service.instance_variable_set "@rackspace_cdn_ssl", nil
+       end
+
+       tests('#ios_url').returns(0) do
+         @instance.ios_url =~ /http:\/\/.+\.iosr\./
+       end
+
+       tests('#streaming_url').returns(0) do
+         @instance.streaming_url =~ /http:\/\/.+\.stream\./
+       end
+       
+     end
+     tests("reload") do
+       @instance.reload
+       returns(nil) { @instance.instance_variable_get("@urls") }
+       returns(nil) { @instance.instance_variable_get("@files") }
+       returns(nil) { @instance.instance_variable_get("@public") }       
+     end
+   end
+
+   directory_attributes[:metadata] = {:draft => 'true'}
+
+   tests('metadata')  do
+     pending if Fog.mocking?
+     
+     model_tests(@service.directories, directory_attributes, Fog.mocking?) do
+       tests('sets metadata on create').returns('true') do
+         @instance.metadata.data
+         container_meta_attributes["X-Container-Meta-Draft"]
+       end
+       tests('update metadata').returns({"X-Container-Meta-Draft"=>"true", "X-Container-Meta-Color"=>"green"}) do
+         @instance.metadata[:color] = 'green'
+         @instance.save
+         container_meta_attributes
+       end
+       tests('set metadata to nil').returns({"X-Container-Meta-Draft"=>"true"}) do
+         @instance.metadata[:color] = nil
+         @instance.save
+         container_meta_attributes
+       end
+       tests('delete metadata').returns({}) do
+         @instance.metadata.delete(:draft)
+         @instance.save
+         container_meta_attributes
+       end
+       
+       tests('should retrieve metadata when necessary') do
+         @service.put_container(@instance.key, {"X-Container-Meta-List-Test"=>"true"} )
+         dir = @service.directories.find {|d| d.key == @instance.key }
+         returns(nil) { dir.instance_variable_get("@metadata") }
+         returns('true') { dir.metadata[:list_test] }
+       end
+       
+       tests("should reload metadata after calling reload").returns("42") do
+         @service.put_container @instance.key, "X-Container-Meta-Answer" => 42
+         @instance.reload
+         @instance.metadata[:answer]
+       end
+       
+       tests("should reload metadata after calling reload").returns("42") do
+         @service.put_container @instance.key, "X-Container-Meta-Answer" => 42
+         @instance.reload
+         @instance.metadata[:answer]
+       end
+       
+     end
+   end
+      
+end

data/tests/rackspace/models/storage/file_tests.rb

@@ -2,8 +2,8 @@ Shindo.tests('Fog::Rackspace::Storage | file', ['rackspace']) do
 
   pending if Fog.mocking?
 
-  def object_meta_attributes
-    @instance.connection.head_object(@directory.key, @instance.key).headers.reject {|k, v| !(k =~ /X-Object-Meta-/)}
+  def object_meta_attributes(file=@instance)
+    @instance.service.head_object(@directory.key, file.key).headers.reject {|k, v| !(k =~ /X-Object-Meta-/)}
   end
 
   def clear_metadata
@@ -35,7 +35,7 @@ Shindo.tests('Fog::Rackspace::Storage | file', ['rackspace']) do
   model_tests(@directory.files, file_attributes, Fog.mocking?) do
 
     tests("#metadata should load empty metadata").returns({}) do
-      @instance.metadata
+      @instance.metadata.data
     end
 
     tests('#save') do
@@ -64,8 +64,91 @@ Shindo.tests('Fog::Rackspace::Storage | file', ['rackspace']) do
           @instance.metadata[:foo] = nil
           @instance.save
           object_meta_attributes
+        end      
+
+        tests("removes one key while leaving the other") do
+          @instance.metadata[:color] = "green"
+          @instance.save
+          returns({"X-Object-Meta-Foo"=>"bar", "X-Object-Meta-Color"=>"green"}) { object_meta_attributes  }
+                    
+          tests("set metadata[:color] = nil").returns({"X-Object-Meta-Foo"=>"bar"}) do
+            @instance.metadata[:color] = nil
+            @instance.save
+            
+            object_meta_attributes
+          end
         end
+      end
 
+      begin
+        tests("sets metadata on create").returns("true") do
+          @file = @directory.files.create :key => 'meta-test', :body => lorem_file, :metadata => {:works => true }
+          object_meta_attributes(@file)["X-Object-Meta-Works"]
+        end
+      ensure
+        @file.destroy if @file
+      end
+      
+      tests('urls') do
+        tests('no CDN') do
+          
+          tests('#public_url') do
+
+             tests('http').returns(nil) do
+               @instance.public_url
+              end
+
+              @directory.cdn_cname = "my_cname.com"        
+              tests('cdn_cname').returns(nil) do
+                @instance.public_url
+              end
+
+              @directory.cdn_cname = nil
+              @directory.service.instance_variable_set "@rackspace_cdn_ssl", true
+              tests('ssl').returns(nil) do
+                @instance.public_url
+              end   
+              @directory.service.instance_variable_set "@rackspace_cdn_ssl", nil             
+           end
+
+           tests('#ios_url').returns(nil) do
+             @instance.ios_url
+           end
+
+           tests('#streaming_url').returns(nil) do
+             @instance.streaming_url
+           end
+        end
+        tests('With CDN') do
+          tests('#public_url') do
+            @directory.public = true
+            @directory.save
+            
+            tests('http').returns(0) do
+              @instance.public_url  =~ /http:\/\/.*#{@instance.key}/
+             end
+
+             @directory.cdn_cname = "my_cname.com"        
+             tests('cdn_cname').returns(0) do
+               @instance.public_url  =~ /my_cname\.com.*#{@instance.key}/
+             end
+
+             @directory.cdn_cname = nil
+             @directory.service.instance_variable_set "@rackspace_cdn_ssl", true
+             tests('ssl').returns(0) do
+               @instance.public_url =~ /https:\/\/.+\.ssl\..*#{@instance.key}/
+             end   
+             @directory.service.instance_variable_set "@rackspace_cdn_ssl", nil
+          end
+
+          tests('#ios_url').returns(0) do
+            @instance.ios_url =~ /http:\/\/.+\.iosr\..*#{@instance.key}/
+          end
+
+          tests('#streaming_url').returns(0) do
+            @instance.streaming_url =~ /http:\/\/.+\.stream\..*#{@instance.key}/
+          end
+        end        
       end
     
       tests('#metadata keys') do
@@ -98,14 +181,6 @@ Shindo.tests('Fog::Rackspace::Storage | file', ['rackspace']) do
           @instance.save
           object_meta_attributes['X-Object-Meta-Foo-Bar']
         end
-
-        @instance.metadata['foo-bar']  = 'baz'  
-        @instance.metadata[:'foo_bar'] = 'bref'  
-        tests("should only support one value per metadata key").returns('bref') do
-          @instance.save
-          object_meta_attributes['X-Object-Meta-Foo-Bar']
-        end
-
       end
 
     end