cloudfiles 1.4.15 → 1.4.16

data/.gitignore

@@ -3,3 +3,4 @@ coverage/*
 doc/*
 pkg/*
 *.gem
+.idea

data/CHANGELOG

@@ -1,3 +1,10 @@
+================================================================================
+1.4.16 (2011/03/17)
+================================================================================
+ o Bugfix on CDN purging. (CvX)
+ o Better OpenStack Swift support with regards to handling the lack of
+   available CDN. (Topper Bowers)
+
 ================================================================================
 1.4.15 (2011/03/09)
 ================================================================================

data/CONTRIBUTORS

@@ -27,3 +27,5 @@ drue
 mkcode
 megaphone
 Nugroho Herucahyono
+CvX
+Topper Bowers

data/VERSION

@@ -1 +1 @@
-1.4.15
+1.4.16

data/cloudfiles.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cloudfiles}
-  s.version = "1.4.15"
+  s.version = "1.4.16"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["H. Wade Minter", "Rackspace Hosting"]
-  s.date = %q{2011-03-10}
+  s.date = %q{2011-03-17}
   s.description = %q{A Ruby version of the Rackspace Cloud Files API.}
   s.email = %q{minter@lunenburg.org}
   s.extra_rdoc_files = [

data/lib/cloudfiles/authentication.rb

@@ -27,6 +27,7 @@ module CloudFiles
       response = server.get(path, hdrhash)
       if (response.code =~ /^20./)
         if response["x-cdn-management-url"]
+          connection.cdn_available = true
           connection.cdnmgmthost   = URI.parse(response["x-cdn-management-url"]).host
           connection.cdnmgmtpath   = URI.parse(response["x-cdn-management-url"]).path
           connection.cdnmgmtport   = URI.parse(response["x-cdn-management-url"]).port

data/lib/cloudfiles/connection.rb

@@ -15,6 +15,10 @@ module CloudFiles
     # API host to authenticate to
     attr_reader :auth_url
 
+    # Set at auth to see if a CDN is available for use
+    attr_accessor :cdn_available
+    alias :cdn_available? :cdn_available
+
     # Hostname of the CDN management server
     attr_accessor :cdnmgmthost
 

data/lib/cloudfiles/container.rb

@@ -20,10 +20,12 @@ module CloudFiles
       @storagepath = self.connection.storagepath + "/" + CloudFiles.escape(@name)
       @storageport = self.connection.storageport
       @storagescheme = self.connection.storagescheme
-      @cdnmgmthost = self.connection.cdnmgmthost
-      @cdnmgmtpath = self.connection.cdnmgmtpath + "/" + CloudFiles.escape(@name) if self.connection.cdnmgmtpath
-      @cdnmgmtport = self.connection.cdnmgmtport
-      @cdnmgmtscheme = self.connection.cdnmgmtscheme
+      if self.connection.cdn_available?
+        @cdnmgmthost = self.connection.cdnmgmthost
+        @cdnmgmtpath = self.connection.cdnmgmtpath + "/" + CloudFiles.escape(@name) if self.connection.cdnmgmtpath
+        @cdnmgmtport = self.connection.cdnmgmtport
+        @cdnmgmtscheme = self.connection.cdnmgmtscheme
+      end
       # Load the metadata now, so we'll get a CloudFiles::Exception::NoSuchContainer exception should the container
       # not exist.
       self.metadata
@@ -57,19 +59,24 @@ module CloudFiles
 
     # Retrieves CDN-Enabled Meta Data
     def cdn_metadata
-      @cdn_metadata ||= (
-        response = self.connection.cfreq("HEAD", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme)
-        cdn_enabled = ((response["x-cdn-enabled"] || "").downcase == "true") ? true : false
-        {
-          :cdn_enabled => cdn_enabled,
-          :cdn_ttl => cdn_enabled ? response["x-ttl"].to_i : nil,
-          :cdn_url => cdn_enabled ? response["x-cdn-uri"] : nil,
-          :cdn_ssl_url => cdn_enabled ? response["x-cdn-ssl-uri"] : nil,
-          :user_agent_acl => response["x-user-agent-acl"],
-          :referrer_acl => response["x-referrer-acl"],
-          :cdn_log => (cdn_enabled and response["x-log-retention"] == "True") ? true : false
-        }
-      )
+      return @cdn_metadata if @cdn_metadata
+      if cdn_available?
+        @cdn_metadata = (
+          response = self.connection.cfreq("HEAD", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme)
+          cdn_enabled = ((response["x-cdn-enabled"] || "").downcase == "true") ? true : false
+          {
+            :cdn_enabled => cdn_enabled,
+            :cdn_ttl => cdn_enabled ? response["x-ttl"].to_i : nil,
+            :cdn_url => cdn_enabled ? response["x-cdn-uri"] : nil,
+            :cdn_ssl_url => cdn_enabled ? response["x-cdn-ssl-uri"] : nil,
+            :user_agent_acl => response["x-user-agent-acl"],
+            :referrer_acl => response["x-referrer-acl"],
+            :cdn_log => (cdn_enabled and response["x-log-retention"] == "True") ? true : false
+          }
+        )
+      else
+        @cdn_metadata = {}
+      end
     end
 
     # Size of the container (in bytes)
@@ -92,7 +99,7 @@ module CloudFiles
     #   private_container.public?
     #   => false
     def cdn_enabled
-      self.cdn_metadata[:cdn_enabled]
+      cdn_available? && self.cdn_metadata[:cdn_enabled]
     end
     alias :cdn_enabled? :cdn_enabled
     alias :public? :cdn_enabled
@@ -134,6 +141,7 @@ module CloudFiles
     # These logs will be periodically (at unpredictable intervals) compressed and uploaded
     # to a “.CDN_ACCESS_LOGS” container in the form of “container_name.YYYYMMDDHH-XXXX.gz”.
     def log_retention=(value)
+      raise Exception::CDNNotAvailable unless cdn_available?
       response = self.connection.cfreq("POST", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme, {"x-log-retention" => value.to_s.capitalize})
       raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code == "201" or response.code == "202")
       return true
@@ -289,6 +297,7 @@ module CloudFiles
     #   container.make_public(:ttl => 8900, :user_agent_acl => "/Mozilla/", :referrer_acl => "/^http://rackspace.com")
     #   => true
     def make_public(options = {:ttl => 86400})
+      raise Exception::CDNNotAvailable unless cdn_available?
       if options.is_a?(Fixnum)
         print "DEPRECATED: make_public takes a hash of options now, instead of a TTL number"
         ttl = options
@@ -315,6 +324,7 @@ module CloudFiles
     #   container.make_private
     #   => true
     def make_private
+      raise Exception::CDNNotAvailable unless cdn_available?
       headers = { "X-CDN-Enabled" => "False" }
       response = self.connection.cfreq("POST", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme, headers)
       raise CloudFiles::Exception::NoSuchContainer, "Container #{@name} does not exist" unless (response.code == "201" || response.code == "202")
@@ -340,21 +350,26 @@ module CloudFiles
     #   container.purge_from_cdn("User@domain.com, User2@domain.com")
     #   => true
     def purge_from_cdn(email=nil)
-        if email
-            headers = {"X-Purge-Email" => email}
-            response = self.connection.cfreq("DELETE", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme, headers)
-            raise CloudFiles::Exception::Connection, "Error Unable to Purge Container: #{@name}" unless (response.code > "200" && response.code < "299")
-        else
-            response = self.connection.cfreq("DELETE", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme)
-            raise CloudFiles::Exception::Connection, "Error Unable to Purge Container: #{@name}" unless (response.code > "200" && response.code < "299")
-        true
-        end
+      raise Exception::CDNNotAvailable unless cdn_available?
+      if email
+          headers = {"X-Purge-Email" => email}
+          response = self.connection.cfreq("DELETE", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme, headers)
+          raise CloudFiles::Exception::Connection, "Error Unable to Purge Container: #{@name}" unless (response.code > "200" && response.code < "299")
+      else
+          response = self.connection.cfreq("DELETE", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme)
+          raise CloudFiles::Exception::Connection, "Error Unable to Purge Container: #{@name}" unless (response.code > "200" && response.code < "299")
+      true
+      end
     end
 
     def to_s # :nodoc:
       @name
     end
 
+    def cdn_available?
+      self.connection.cdn_available?
+    end
+
   end
 
 end

data/lib/cloudfiles/exception.rb

@@ -58,7 +58,8 @@ module CloudFiles
     end
     class ExpiredAuthToken   < ExpiredAuthTokenException # :nodoc:
     end
+    class CDNNotAvailable    < StandardError
+    end
     
   end
 end
-    

data/lib/cloudfiles/storage_object.rb

@@ -24,10 +24,12 @@ module CloudFiles
       @storagepath = self.container.connection.storagepath + "/#{CloudFiles.escape @containername}/#{CloudFiles.escape @name, '/'}"
       @storageport = self.container.connection.storageport
       @storagescheme = self.container.connection.storagescheme
-      @cdnmgmthost = self.container.connection.cdnmgmthost
-      @cdnmgmtpath = self.container.connection.cdnmgmtpath + "/#{CloudFiles.escape @containername}/#{CloudFiles.escape @name, '/'}"
-      @cdnmgmtport = self.container.connection.cdnmgmtport
-      @cdnmgmtscheme = self.container.connection.cdnmgmtscheme
+      if self.container.connection.cdn_available?
+        @cdnmgmthost = self.container.connection.cdnmgmthost
+        @cdnmgmtpath = self.container.connection.cdnmgmtpath + "/#{CloudFiles.escape @containername}/#{CloudFiles.escape @name, '/'}"
+        @cdnmgmtport = self.container.connection.cdnmgmtport
+        @cdnmgmtscheme = self.container.connection.cdnmgmtscheme
+      end
       if force_exists
         raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" unless container.object_exists?(objectname)
       end
@@ -210,16 +212,17 @@ module CloudFiles
     #                                                         
     #   obj.purge_from_cdn("User@domain.com, User2@domain.com")
     #   => true
-    def purge_from_cdn(email=nil)                                                                  
-        if email
-            headers = {"X-Purge-Email" => email}
-            response = self.container.connection.cfreq("DELETE", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme, headers)
-            raise CloudFiles::Exception::Connection, "Error Unable to Purge Object: #{@name}" unless (response.code.to_s =~ /^20.$/)
-        else
-            response = self.container..connection.cfreq("DELETE", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme)
-            raise CloudFiles::Exception::Connection, "Error Unable to Purge Object: #{@name}" unless (response.code.to_s =~ /^20.$/)
-        end
-        true
+    def purge_from_cdn(email=nil)
+      raise Exception::CDNNotAvailable unless cdn_available?
+      if email
+          headers = {"X-Purge-Email" => email}
+          response = self.container.connection.cfreq("DELETE", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme, headers)
+          raise CloudFiles::Exception::Connection, "Error Unable to Purge Object: #{@name}" unless (response.code.to_s =~ /^20.$/)
+      else
+          response = self.container.connection.cfreq("DELETE", @cdnmgmthost, @cdnmgmtpath, @cdnmgmtport, @cdnmgmtscheme)
+          raise CloudFiles::Exception::Connection, "Error Unable to Purge Object: #{@name}" unless (response.code.to_s =~ /^20.$/)
+      end
+      true
     end
 
     # A convenience method to stream data into an object from a local file (or anything that can be loaded by Ruby's open method)
@@ -344,6 +347,10 @@ module CloudFiles
 
     private
 
+      def cdn_available?
+        @cdn_available ||= self.container.connection.cdn_available?
+      end
+
       def make_path(path) # :nodoc:
         if path == "." || path == "/"
           return

data/test/cloudfiles_authentication_test.rb

@@ -10,7 +10,7 @@ class CloudfilesAuthenticationTest < Test::Unit::TestCase
     server = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
     server.stubs(:get).returns(response)
     CloudFiles::Authentication.any_instance.stubs(:get_server).returns(server)
-    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true, :snet? => false, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0')
+    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true, :snet? => false, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true, :cdn_available= => true)
     result = CloudFiles::Authentication.new(@connection)
     assert_equal result.class, CloudFiles::Authentication
   end
@@ -21,7 +21,7 @@ class CloudfilesAuthenticationTest < Test::Unit::TestCase
     server = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
     server.stubs(:get).returns(response)
     CloudFiles::Authentication.any_instance.stubs(:get_server).returns(server)
-    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true, :snet? => true, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0')
+    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true, :snet? => true, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true, :cdn_available= => true)
     result = CloudFiles::Authentication.new(@connection)
     assert_equal result.class, CloudFiles::Authentication
   end
@@ -32,7 +32,7 @@ class CloudfilesAuthenticationTest < Test::Unit::TestCase
     server = mock(:use_ssl= => true, :verify_mode= => true, :start => true)
     server.stubs(:get).returns(response)
     CloudFiles::Authentication.any_instance.stubs(:get_server).returns(server)
-    @connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true,  :auth_url => 'https://auth.api.rackspacecloud.com/v1.0')
+    @connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true,  :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true)
     assert_raises(CloudFiles::Exception::Authentication) do
       result = CloudFiles::Authentication.new(@connection)
     end
@@ -40,7 +40,7 @@ class CloudfilesAuthenticationTest < Test::Unit::TestCase
     
   def test_bad_hostname
     Net::HTTP.stubs(:new).raises(CloudFiles::Exception::Connection)
-    @connection = stub(:proxy_host => nil, :proxy_port => nil, :authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0')
+    @connection = stub(:proxy_host => nil, :proxy_port => nil, :authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true)
     assert_raises(CloudFiles::Exception::Connection) do
       result = CloudFiles::Authentication.new(@connection)
     end

data/test/cloudfiles_container_test.rb

@@ -4,7 +4,7 @@ require 'test_helper'
 class CloudfilesContainerTest < Test::Unit::TestCase
   
   def test_object_creation
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
     response.stubs(:code).returns('204')
     connection.stubs(:cfreq => response)
@@ -15,9 +15,20 @@ class CloudfilesContainerTest < Test::Unit::TestCase
     assert_equal @container.cdn_url, nil
     assert_equal @container.cdn_ttl, nil
   end
+
+  def test_object_creation_with_no_cdn_available
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => false)
+    response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
+    response.stubs(:code).returns('204')
+    connection.stubs(:cfreq => response)
+    @container = CloudFiles::Container.new(connection, 'test_container')
+    assert_equal 'test_container', @container.name
+    assert_equal CloudFiles::Container, @container.class
+    assert_equal false, @container.public?
+  end
   
   def test_object_creation_no_such_container
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
     response.stubs(:code).returns('999')
     connection.stubs(:cfreq => response)
@@ -27,7 +38,7 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   
   def test_object_creation_with_cdn
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'x-cdn-enabled' => 'True', 'x-cdn-uri' => 'http://cdn.test.example/container', 'x-ttl' => '86400'}
     response.stubs(:code).returns('204')
     connection.stubs(:cfreq => response)
@@ -73,7 +84,7 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   
   def test_empty_is_false
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
     response.stubs(:code).returns('204')
     connection.stubs(:cfreq => response)
@@ -82,7 +93,7 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   
   def test_empty_is_true
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '0', 'x-container-object-count' => '0'}
     response.stubs(:code).returns('204')
     connection.stubs(:cfreq => response)
@@ -91,7 +102,7 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   
   def test_log_retention_is_true
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '0', 'x-container-object-count' => '0', 'x-cdn-enabled' => 'True', 'x-log-retention' => 'True'}
     response.stubs(:code).returns('204')
     connection.stubs(:cfreq => response)
@@ -240,12 +251,20 @@ class CloudfilesContainerTest < Test::Unit::TestCase
     assert(@container.log_retention='false')
   end
   
+  def test_purge_from_cdn_succeeds
+    build_net_http_object
+    assert_nothing_raised do
+      @container.purge_from_cdn
+      @container.purge_from_cdn("small.fox@hole.org")
+    end
+  end
+  
   private
   
   def build_net_http_object(args={:code => '204' }, cfreq_expectations={})
     CloudFiles::Container.any_instance.stubs(:populate).returns(true)
     CloudFiles::Container.any_instance.stubs(:metadata).returns({})
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     args[:response] = {} unless args[:response]
     response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token', 'last-modified' => Time.now.to_s}.merge(args[:response])
     response.stubs(:code).returns(args[:code])

data/test/cloudfiles_storage_object_test.rb

@@ -4,7 +4,19 @@ require 'test_helper'
 class CloudfilesStorageObjectTest < Test::Unit::TestCase
   
   def test_object_creation
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
+    response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'last-modified' => Time.now.to_s}
+    response.stubs(:code).returns('204')
+    connection.stubs(:cfreq => response)
+    container = CloudFiles::Container.new(connection, 'test_container')
+    @object = CloudFiles::StorageObject.new(container, 'test_object')
+    assert_equal @object.name, 'test_object'
+    assert_equal @object.class, CloudFiles::StorageObject
+    assert_equal @object.to_s, 'test_object'
+  end
+
+  def test_object_creation_with_no_cdn_available
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => false)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'last-modified' => Time.now.to_s}
     response.stubs(:code).returns('204')
     connection.stubs(:cfreq => response)
@@ -16,7 +28,7 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
   end
   
   def test_object_creation_with_invalid_name
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'last-modified' => Time.now.to_s}
     response.stubs(:code).returns('204')
     connection.stubs(:cfreq => response)
@@ -108,7 +120,7 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
   end
   
   def test_read_metadata_succeeds
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'x-object-meta-foo' => 'Bar', 'last-modified' => Time.now.to_s}
     response.stubs(:code).returns('204')
     connection.stubs(:cfreq => response)
@@ -127,7 +139,7 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
   end
   
   def test_write_with_make_path
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5', 'last-modified' => Time.now.to_s}
     response.stubs(:code).returns('204').then.returns('204').then.returns('201').then.returns('204')
     connection.stubs(:cfreq => response)
@@ -161,6 +173,14 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
     end
   end
   
+  def test_purge_from_cdn_succeeds
+    build_net_http_object
+    assert_nothing_raised do
+      @object.purge_from_cdn
+      @object.purge_from_cdn("small.fox@hole.org")
+    end
+  end
+  
   def test_write_with_no_data_dies
     build_net_http_object
     assert_raise(CloudFiles::Exception::Syntax) do
@@ -194,7 +214,7 @@ class CloudfilesStorageObjectTest < Test::Unit::TestCase
   def build_net_http_object(args={:code => '204' })
     CloudFiles::Container.any_instance.stubs(:metadata).returns({})
     CloudFiles::Container.any_instance.stubs(:populate).returns(true)
-    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https')
+    connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdnmgmthost => 'cdm.test.example', :cdnmgmtpath => '/dummy/path', :cdnmgmtport => 443, :cdnmgmtscheme => 'https', :cdn_available? => true)
     args[:response] = {} unless args[:response]
     response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token', 'last-modified' => Time.now.to_s}.merge(args[:response])
     response.stubs(:code).returns(args[:code])

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cloudfiles
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 39
   prerelease: 
   segments: 
   - 1
   - 4
-  - 15
-  version: 1.4.15
+  - 16
+  version: 1.4.16
 platform: ruby
 authors: 
 - H. Wade Minter
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-10 00:00:00 -05:00
+date: 2011-03-17 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency