RubyGems - cloudfiles - Versions diffs - 1.4.18 → 1.5.0 - Mend

cloudfiles 1.4.18 → 1.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

data/CHANGELOG +6 -0
data/CONTRIBUTORS +1 -0
data/cloudfiles.gemspec +5 -3
data/lib/client.rb +620 -0
data/lib/cloudfiles.rb +1 -1
data/lib/cloudfiles/authentication.rb +10 -25
data/lib/cloudfiles/connection.rb +55 -123
data/lib/cloudfiles/container.rb +89 -73
data/lib/cloudfiles/storage_object.rb +52 -36
data/lib/cloudfiles/version.rb +1 -1
data/test/cloudfiles_authentication_test.rb +17 -22
data/test/cloudfiles_client_test.rb +797 -0
data/test/cloudfiles_connection_test.rb +53 -194
data/test/cloudfiles_container_test.rb +253 -121
data/test/cloudfiles_storage_object_test.rb +51 -65
data/test/test_helper.rb +1 -0
metadata +12 -10

data/test/cloudfiles_connection_test.rb CHANGED

@@ -6,6 +6,8 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
   def setup
     CloudFiles::Authentication.expects(:new).returns(true)
     @connection = CloudFiles::Connection.new('dummy_user', 'dummy_key')
+    @connection.storagescheme = "http"
+    @connection.storageport = 80
     @connection.storagehost = "test.setup.example"
     @connection.storagepath = "/dummypath/setup"
     @connection.cdnmgmthost = "test.cdn.example"
@@ -17,6 +19,13 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
     assert_equal @connection.authkey, 'dummy_key'
   end
+  def test_initalize_with_hash
+    CloudFiles::Authentication.expects(:new).returns(true)
+    @hash_connection = CloudFiles::Connection.new(:username => 'dummy_user', :api_key => 'dummy_key')
+    assert_equal @hash_connection.authuser, "dummy_user"
+    assert_equal @hash_connection.authkey, "dummy_key"
+  end
   def test_authok
     # This would normally be set in CloudFiles::Authentication
     assert_equal @connection.authok?, false
@@ -30,326 +39,176 @@ class CloudfilesConnectionTest < Test::Unit::TestCase
     @connection.expects(:snet?).returns(true)
     assert_equal @connection.snet?, true
   end
-  def test_cfreq_get
-    build_net_http_object
-    assert_nothing_raised do
-      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
-    end
-  end
-  def test_cfreq_post
-    build_net_http_object
-    assert_nothing_raised do
-      response = @connection.cfreq("POST", "test.server.example", "/dummypath", "80", "http")
-    end
-  end
-  def test_cfreq_put
-    build_net_http_object
-    assert_nothing_raised do
-      response = @connection.cfreq("PUT", "test.server.example", "/dummypath", "80", "http")
-    end
-  end
-  def test_cfreq_delete
-    build_net_http_object
-    assert_nothing_raised do
-      response = @connection.cfreq("DELETE", "test.server.example", "/dummypath", "80", "http")
-    end
-  end
-  def test_cfreq_with_static_data
-    build_net_http_object
-    assert_nothing_raised do
-      response = @connection.cfreq("PUT", "test.server.example", "/dummypath", "80", "http", {}, "This is string data")
-    end
-  end
-  def test_cfreq_with_stream_data
-    build_net_http_object
-    require 'tempfile'
-    file = Tempfile.new("test")
-    assert_nothing_raised do
-      response = @connection.cfreq("PUT", "test.server.example", "/dummypath", "80", "http", {}, file)
-    end
-  end
-  def test_cfreq_head
-    build_net_http_object
-    assert_nothing_raised do
-      response = @connection.cfreq("HEAD", "test.server.example", "/dummypath", "80", "http")
-    end
-  end
-  def test_storage_request
-    build_net_http_object
-    assert_nothing_raised do
-      response = @connection.storage_request("HEAD", "dummypath")
-    end
-  end
-  def test_storage_request_adds_path
-    build_net_http_object({}, {:method => "HEAD", :path => "#{@connection.storagepath}/dummypath"})
-    assert_nothing_raised do
-      response = @connection.storage_request("HEAD", "dummypath")
-    end
-  end
-  def test_storage_path_does_not_add_path_when_absolute
-    build_net_http_object({}, {:method => "HEAD", :path => "/dummypath"})
-    assert_nothing_raised do
-      response = @connection.storage_request("HEAD", "/dummypath")
-    end
-  end
-  def test_cdn_request
-    build_net_http_object
-    assert_nothing_raised do
-      response = @connection.cdn_request("HEAD", "dummypath")
-    end
-  end
-  def test_cdn_request_adds_path
-    build_net_http_object({}, {:method => "HEAD", :path => "#{@connection.cdnmgmtpath}/dummypath"})
-    assert_nothing_raised do
-      response = @connection.cdn_request("HEAD", "dummypath")
-    end
-  end
-  def test_cdn_path_does_not_add_path_when_absolute
-    build_net_http_object({}, {:method => "HEAD", :path => "/dummypath"})
-    assert_nothing_raised do
-      response = @connection.cdn_request("HEAD", "/dummypath")
-    end
-  end
-  def test_net_http_raises_connection_exception
-    Net::HTTP.expects(:new).raises(CloudFiles::Exception::Connection)
-    assert_raises(CloudFiles::Exception::Connection) do
-      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
-    end
-  end
-  def test_net_http_raises_one_eof_exception
-    response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}
-    response.stubs(:code).returns('204')
-    server = stub(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
-    server.stubs(:request).raises(EOFError).then.returns(response)
-    Net::HTTP.stubs(:new).returns(server)
-    assert_nothing_raised do
-      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "443", "https")
-    end
-  end
-  def test_net_http_raises_one_expired_token
-    CloudFiles::Authentication.expects(:new).returns(true)
-    response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}
-    response.stubs(:code).returns('401').then.returns('204')
-    server = stub(:use_ssl= => true, :verify_mode= => true, :start => true)
-    server.stubs(:request).returns(response)
-    Net::HTTP.stubs(:new).returns(server)
-    assert_nothing_raised do
-      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
-    end
-  end
-  def test_net_http_raises_continual_eof_exceptions
-    response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}
-    response.stubs(:code).returns('204')
-    server = stub(:use_ssl= => true, :verify_mode= => true, :start => true)
-    server.stubs(:finish).returns(true)
-    server.stubs(:request).raises(EOFError)
-    CloudFiles::Connection.any_instance.stubs(:get_info).returns({:bytes => @bytes, :count => @count})
-    Net::HTTP.stubs(:new).returns(server)
-    assert_raises(CloudFiles::Exception::Connection) do
-      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
-    end
-  end
   def test_get_info
-    build_net_http_object(:response => {'x-account-bytes-used' => '9999', 'x-account-container-count' => '5'}, :code => '204')
+    @connection.authok = true
+    response = {'x-account-bytes-used' => '9999', 'x-account-container-count' => '5'}
+    SwiftClient.stubs(:head_account).returns(response)
     @connection.get_info
     assert_equal @connection.bytes, 9999
     assert_equal @connection.count, 5
   end
   def test_get_info_fails
-    build_net_http_object(:response => {'x-account-bytes-used' => '9999', 'x-account-container-count' => '5'}, :code => '999')
+    @connection.authok = true
+    SwiftClient.stubs(:head_account).raises(ClientException.new("foo", :http_status => 999))
     assert_raises(CloudFiles::Exception::InvalidResponse) do
       @connection.get_info
     end
   end
   def test_public_containers
-    build_net_http_object(:body => "foo\nbar\nbaz", :code => '200', :response => {})
+    response = [nil, [{"name" => 'foo'}, {"name" => "bar"}, {"name" => "baz"}]]
+    SwiftClient.stubs(:get_account).returns(response)
     public_containers = @connection.public_containers
     assert_equal public_containers.size, 3
     assert_equal public_containers.first, 'foo'
   end
   def test_public_containers_empty
-    build_net_http_object
+    response = [nil, []]
+    SwiftClient.stubs(:get_account).returns(response)
     public_containers = @connection.public_containers
     assert_equal public_containers.size, 0
     assert_equal public_containers.class, Array
   end
   def test_public_containers_exception
-    build_net_http_object(:code => '999')
+    SwiftClient.stubs(:get_account).raises(ClientException.new("test_public_containers_exception", :http_status => 999))
     assert_raises(CloudFiles::Exception::InvalidResponse) do
       public_containers = @connection.public_containers
     end
   end
   def test_delete_container
-    build_net_http_object
+    SwiftClient.stubs(:delete_container).returns(nil)
     response = @connection.delete_container("good_container")
     assert_equal response, true
   end
   def test_delete_nonempty_container
-    build_net_http_object(:code => '409')
+    SwiftClient.stubs(:delete_container).raises(ClientException.new("test_delete_nonempty_container", :http_status => 409))
     assert_raises(CloudFiles::Exception::NonEmptyContainer) do
       response = @connection.delete_container("not_empty")
     end
   end
   def test_delete_unknown_container
-    build_net_http_object(:code => '999')
+    SwiftClient.stubs(:delete_container).raises(ClientException.new("test_delete_unknown_container", :http_status => 999))
     assert_raises(CloudFiles::Exception::NoSuchContainer) do
       response = @connection.delete_container("not_empty")
     end
   end
   def test_create_container
-    CloudFiles::Container.any_instance.stubs(:populate)
-    build_net_http_object(:code => '201')
+    response = [ { "content-type"=>"application/json; charset=utf-8", "x-container-object-count"=>"1", "date"=>"", "x-container-bytes-used"=>"0", "content-length"=>"0", "accept-ranges"=>"bytes", "x-trans-id"=>"foo" }, [ { "bytes"=>0, "name"=>"foo.jpg", "content_type"=>"image/jpeg", "hash"=>"foo", "last_modified"=>"" } ] ]
+    CloudFiles::Container.any_instance.stubs(:container_metadata).returns(response[0])
+    SwiftClient.stubs(:put_container).returns(nil)
     container = @connection.create_container('good_container')
     assert_equal container.name, 'good_container'
   end
   def test_create_container_with_invalid_name
-    CloudFiles::Container.stubs(:new)
     assert_raise(CloudFiles::Exception::Syntax) do
       container = @connection.create_container('a'*300)
     end
   end
   def test_create_container_name_filter
-    CloudFiles::Container.any_instance.stubs(:populate)
-    build_net_http_object(:code => '201')
     assert_raises(CloudFiles::Exception::Syntax) do
       container = @connection.create_container('this/has/bad?characters')
     end
   end
+  def test_create_container_error
+    SwiftClient.stubs(:put_container).raises(ClientException.new("test_create_container_general_error", :http_status => 999))
+    assert_raise(CloudFiles::Exception::InvalidResponse) do
+      container = @connection.create_container('foobar')
+    end
+  end
   def test_container_exists_true
-    build_net_http_object
+    response = {"x-container-object-count"=>"0", "date"=>"Fri, 02 Sep 2011 20:27:15 GMT", "x-container-bytes-used"=>"0", "content-length"=>"0", "accept-ranges"=>"bytes", "x-trans-id"=>"foo"}
+    SwiftClient.stubs(:head_container).returns(response)
     assert_equal @connection.container_exists?('this_container_exists'), true
   end
   def test_container_exists_false
-    build_net_http_object(:code => '999')
+    SwiftClient.stubs(:head_container).raises(ClientException.new("test_container_exists_false", :http_status => 404))
     assert_equal @connection.container_exists?('this_does_not_exist'), false
   end
   def test_fetch_exisiting_container
-    CloudFiles::Container.any_instance.stubs(:populate)
-    build_net_http_object
+    response = [ { "content-type"=>"application/json; charset=utf-8", "x-container-object-count"=>"1", "date"=>"", "x-container-bytes-used"=>"0", "content-length"=>"0", "accept-ranges"=>"bytes", "x-trans-id"=>"foo" }, [ { "bytes"=>0, "name"=>"foo.jpg", "content_type"=>"image/jpeg", "hash"=>"foo", "last_modified"=>"" } ] ]
+    CloudFiles::Container.any_instance.stubs(:container_metadata).returns(response[0])
     container = @connection.container('good_container')
     assert_equal container.name, 'good_container'
   end
   def test_fetch_nonexistent_container
     CloudFiles::Container.any_instance.stubs(:container_metadata).raises(CloudFiles::Exception::NoSuchContainer)
-    build_net_http_object
     assert_raise(CloudFiles::Exception::NoSuchContainer) do
       container = @connection.container('bad_container')
     end
   end
   def test_containers
-    build_net_http_object(:body => "foo\nbar\nbaz\nboo", :code => '200')
+    response = [nil, [{"name" => 'foo'}, {"name" => "bar"}, {"name" => "baz"}, {"name" => "boo"}]]
+    SwiftClient.stubs(:get_account).returns(response)
     containers = @connection.containers
     assert_equal containers.size, 4
     assert_equal containers.first, 'foo'
   end
   def test_containers_with_limit
-    build_net_http_object_with_cfreq_expectations({:body => "foo", :code => '200'},
-                                                  {:path => includes('limit=1')})
+    response = [nil, [{"name" => 'foo'}]]
+    SwiftClient.stubs(:get_account).returns(response)
     containers = @connection.containers(1)
     assert_equal containers.size, 1
     assert_equal containers.first, 'foo'
   end
   def test_containers_with_marker
-    build_net_http_object_with_cfreq_expectations({:body => "boo", :code => '200'},
-                                                  {:path => includes('marker=baz')})
+    response = [nil, [{"name" => "boo"}]]
+    SwiftClient.stubs(:get_account).returns(response)
     containers = @connection.containers(0, 'baz')
     assert_equal containers.size, 1
     assert_equal containers.first, 'boo'
   end
   def test_no_containers_yet
-    build_net_http_object
+    response = [nil, []]
+    SwiftClient.stubs(:get_account).returns(response)
     containers = @connection.containers
     assert_equal containers.size, 0
     assert_equal containers.class, Array
   end
   def test_containers_bad_result
-    build_net_http_object(:code => '999')
+    SwiftClient.stubs(:get_account).raises(ClientException.new("foo", :http_status => 999))
     assert_raises(CloudFiles::Exception::InvalidResponse) do
       containers = @connection.containers
     end
   end
   def test_containers_detail
-    body = %{<?xml version="1.0" encoding="UTF-8"?>
-    <account name="MossoCloudFS_012559c7-030d-4bbd-8538-7468896b0e7f">
-    <container><name>Books</name><count>0</count><bytes>0</bytes></container><container><name>cftest</name><count>0</count><bytes>0</bytes></container><container><name>cszsa</name><count>1</count><bytes>82804</bytes></container><container><name>CWX</name><count>3</count><bytes>3645134</bytes></container><container><name>test</name><count>2</count><bytes>20</bytes></container><container><name>video</name><count>2</count><bytes>34141298</bytes></container><container><name>webpics</name><count>1</count><bytes>177496</bytes></container></account>}
-    build_net_http_object(:body => body, :code => '200')
+    response = [nil, [{"bytes"=>"42", "name"=>"CWX", "count"=>"3"}]]
+    SwiftClient.stubs(:get_account).returns(response)
     details = @connection.containers_detail
     assert_equal details['CWX'][:count], "3"
   end
   def test_empty_containers_detail
-    build_net_http_object
+    response = [nil, []]
+    SwiftClient.stubs(:get_account).returns(response)
     details = @connection.containers_detail
     assert_equal details, {}
   end
   def test_containers_detail_bad_response
-    build_net_http_object(:code => '999')
+    SwiftClient.stubs(:get_account).raises(ClientException.new("foo", :http_status => 999))
     assert_raises(CloudFiles::Exception::InvalidResponse) do
       details = @connection.containers_detail
     end
   end
-  private
-  def build_net_http_object(args={}, cfreq_expectations={})
-    args.merge!(:code => '204') unless args[:code]
-    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'}.merge(args[:response])
-    response.stubs(:code).returns(args[:code])
-    response.stubs(:body).returns args[:body] || nil
-    if !cfreq_expectations.empty?
-      parameter_expectations = [anything(), anything(), anything(), anything(), anything(), anything(), anything(), anything()]
-      parameter_expectations[0] = cfreq_expectations[:method] if cfreq_expectations[:method]
-      parameter_expectations[2] = cfreq_expectations[:path] if cfreq_expectations[:path]
-      @connection.expects(:cfreq).with(*parameter_expectations).returns(response)
-    else
-      @connection.stubs(:cfreq).returns(response)
-    end
-  end
-  def build_net_http_object_with_cfreq_expectations(args={:code => '204' }, cfreq_expectations={})
-    build_net_http_object(args, cfreq_expectations)
-  end
 end

data/test/cloudfiles_container_test.rb CHANGED

@@ -4,11 +4,9 @@ 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', :cdn_available? => 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', :cdn_available? => true, :cdnurl => nil, :storageurl => nil, :authtoken => "dummy token")
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
-    response.stubs(:code).returns('204')
-    connection.stubs(:storage_request => response)
-    connection.stubs(:cdn_request => response)
+    SwiftClient.stubs(:head_container).returns(response)
     @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal @container.name, 'test_container'
     assert_equal @container.class, CloudFiles::Container
@@ -18,10 +16,9 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   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)
+    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, :cdnurl => nil, :storageurl => nil, :authtoken => "dummy token")
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
-    response.stubs(:code).returns('204')
-    connection.stubs(:storage_request => response)
+    SwiftClient.stubs(:head_container).returns(response)
     @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal 'test_container', @container.name
     assert_equal CloudFiles::Container, @container.class
@@ -29,21 +26,17 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   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', :cdn_available? => true)
-    response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
-    response.stubs(:code).returns('999')
-    connection.stubs(:storage_request => response)
+    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, :cdnurl => nil, :storageurl => nil, :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).raises(ClientException.new("foobar", :http_status => 404))
     assert_raise(CloudFiles::Exception::NoSuchContainer) do
       @container = CloudFiles::Container.new(connection, 'test_container')
     end
   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', :cdn_available? => 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', :cdn_available? => true, :cdnurl => nil, :storageurl => nil, :authtoken => "dummy token")
     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(:storage_request => response)
-    connection.stubs(:cdn_request => response)
+    SwiftClient.stubs(:head_container).returns(response)
     @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal @container.name, 'test_container'
     assert_equal @container.cdn_enabled, true
@@ -53,183 +46,255 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   def test_to_s
-    build_net_http_object
+    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, :cdnurl => nil, :storageurl => nil, :authtoken => "dummy token")
+    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'}
+    SwiftClient.stubs(:head_container).returns(response)
+    @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal @container.to_s, 'test_container'
   end
   def test_make_private_succeeds
-    build_net_http_object(:code => '201', :cdn_request => 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', :cdn_available? => true, :cdnurl => nil, :storageurl => nil, :authtoken => "dummy token", :container_metadata => {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'})
+    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'}
+    SwiftClient.stubs(:head_container).returns(response)
+    SwiftClient.stubs(:post_container).returns(nil)
+    @container = CloudFiles::Container.new(connection, 'test_container')
     assert_nothing_raised do
       @container.make_private
     end
   end
   def test_make_private_fails
-    build_net_http_object(:code => '999', :cdn_request => 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', :cdn_available? => true, :cdnurl => nil, :storageurl => nil, :authtoken => "dummy token", :container_metadata => {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'})
+    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'}
+    SwiftClient.stubs(:head_container).returns(response)
+    SwiftClient.stubs(:post_container).raises(ClientException.new("test_make_private_fails", :http_status => 404))
+    @container = CloudFiles::Container.new(connection, 'test_container')
     assert_raises(CloudFiles::Exception::NoSuchContainer) do
       @container.make_private
     end
   end
   def test_make_public_succeeds
-    build_net_http_object(:code => '201', :cdn_request => 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', :cdn_available? => true, :cdnurl => 'http://cdn.test.example/container', :storageurl => nil, :authtoken => "dummy token")
+    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'}
+    SwiftClient.stubs(:put_container).returns(nil)
+    SwiftClient.stubs(:head_container).returns(response)
+    CloudFiles::Container.any_instance.stubs(:post_with_headers).returns(nil)
+    @container = CloudFiles::Container.new(connection, 'test_container')
     assert_nothing_raised do
       @container.make_public
     end
   end
+  def test_make_public_fixnum_ttl_deprication_warning_and_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', :cdn_available? => true, :cdnurl => 'http://cdn.test.example/container', :storageurl => nil, :authtoken => "dummy token")
+    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'}
+    SwiftClient.stubs(:put_container).returns(nil)
+    SwiftClient.stubs(:head_container).returns(response)
+    CloudFiles::Container.any_instance.stubs(:post_with_headers).returns(nil)
+    @container = CloudFiles::Container.new(connection, 'test_container')
+    assert_nothing_raised do
+      @container.make_public(123)
+    end
+  end
   def test_make_public_fails
-    build_net_http_object(:code => '999', :cdn_request => 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', :cdn_available? => true, :cdnurl => 'http://cdn.test.example/container', :storageurl => nil, :authtoken => "dummy token")
+    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'}
+    SwiftClient.stubs(:head_container).returns(response)
+    SwiftClient.stubs(:put_container).raises(ClientException.new("test_make_public_fails", :http_status => 404))
+    CloudFiles::Container.any_instance.stubs(:post_with_headers).returns(nil)
+    @container = CloudFiles::Container.new(connection, 'test_container')
     assert_raises(CloudFiles::Exception::NoSuchContainer) do
       @container.make_public
     end
   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', :cdn_available? => 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', :cdn_available? => true, :cdnurl => 'http://cdn.test.example/container', :storageurl => nil, :authtoken => "dummy token")
     response = {'x-container-bytes-used' => '42', 'x-container-object-count' => '5'}
-    response.stubs(:code).returns('204')
-    connection.stubs(:storage_request => response)
+    SwiftClient.stubs(:head_container).returns(response)
     @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal @container.empty?, false
   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', :cdn_available? => 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', :cdn_available? => true, :cdnurl => 'http://cdn.test.example/container', :storageurl => nil, :authtoken => "dummy token")
     response = {'x-container-bytes-used' => '0', 'x-container-object-count' => '0'}
-    response.stubs(:code).returns('204')
-    connection.stubs(:storage_request => response)
+    SwiftClient.stubs(:head_container).returns(response)
     @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal @container.empty?, true
   end
   def build_acl_test_state(opts={})
-    @connection = stub(:storagehost => 'test.storage.example', :storagepath => '/dummy/path', :storageport => 443, :storagescheme => 'https', :cdn_available? => 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', :cdn_available? => false, :cdnurl => 'http://cdn.test.example/container', :storageurl => nil, :authtoken => "dummy token")
     @response = {
       'x-container-bytes-used' => '0',
       'x-container-object-count' => '0',
     }.merge(opts.fetch(:response, {}))
     @response.stubs(:code).returns(opts.fetch(:code, '204'))
-    @connection.stubs(:storage_request => @response)
+    if opts[:code] =~ /^![2]0/
+      SwiftClient.stubs(:head_container).raises(ClientException.new("acl_test_state", :http_status => opts.fetch(:code, 204)))
+    else
+      SwiftClient.stubs(:head_container).returns(@response)
+    end
     @container = CloudFiles::Container.new(@connection, 'test_container')
   end
   def test_read_acl_is_set_from_headers
-    build_acl_test_state :response => { 'x-container-read' => '.r:*' }, :code => '204'
+    @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, :cdnurl => 'http://cdn.test.example/container', :storageurl => nil, :authtoken => "dummy token")
+    @response = {'x-container-bytes-used' => '0','x-container-object-count' => '0', 'x-container-read' => '.r:*'}
+    SwiftClient.stubs(:head_container).returns(@response)
+    @container = CloudFiles::Container.new(@connection, 'test_container')
     assert_equal @response["x-container-read"], @container.read_acl
   end
   def test_set_read_acl_fails
-    build_acl_test_state
-    response = stub(:code => '999')
-    @connection.stubs(:storage_request => response)
+    @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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '0'})
+    SwiftClient.stubs(:post_container).raises(ClientException.new("test_set_read_acl_fails", :http_status => 404))
+    @container = CloudFiles::Container.new(@connection, 'test_container')
     assert_raises(CloudFiles::Exception::NoSuchContainer) do
       @container.set_read_acl('.r:*')
     end
   end
   def test_set_read_acl_succeeds
-    build_acl_test_state
-    @connection.stubs(:storage_request => stub(:code => '204'))
+    @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, :cdnurl => 'http://cdn.test.example/container', :storageurl => nil, :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '0', 'x-container-write' => '.r:*'})
+    SwiftClient.stubs(:post_container).returns(true)
+    @container = CloudFiles::Container.new(@connection, 'test_container')
     assert_equal @container.set_read_acl('.r:*'), true
   end
   def test_write_acl_is_set_from_headers
-    build_acl_test_state :response => { 'x-container-write' => '.r:*' }, :code => '204'
+    @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, :cdnurl => 'http://cdn.test.example/container', :storageurl => nil, :authtoken => "dummy token")
+    @response = {'x-container-bytes-used' => '0','x-container-object-count' => '0', 'x-container-write' => '.r:*'}
+    SwiftClient.stubs(:head_container).returns(@response)
+    @container = CloudFiles::Container.new(@connection, 'test_container')
     assert_equal @response["x-container-write"], @container.write_acl
   end
   def test_set_write_acl_fails
-    build_acl_test_state
-    response = stub(:code => '999')
-    @connection.stubs(:storage_request => response)
+    @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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '0'})
+    SwiftClient.stubs(:post_container).raises(ClientException.new("test_set_write_acl_fails", :http_status => 404))
+    @container = CloudFiles::Container.new(@connection, 'test_container')
     assert_raises(CloudFiles::Exception::NoSuchContainer) do
       @container.set_write_acl('.r:*')
     end
   end
   def test_set_write_acl_succeeds
-    build_acl_test_state
-    @connection.stubs(:storage_request => stub(:code => '204'))
+    @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, :cdnurl => 'http://cdn.test.example/container', :storageurl => nil, :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '0', 'x-container-write' => '.r:*'})
+    SwiftClient.stubs(:post_container).returns(true)
+    @container = CloudFiles::Container.new(@connection, 'test_container')
     assert_equal @container.set_write_acl('.r:*'), true
   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', :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(:cdn_request => response)
-    connection.stubs(:storage_request => response)
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0', 'x-container-object-count' => '0', 'x-cdn-enabled' => 'True', 'x-log-retention' => 'True'})
     @container = CloudFiles::Container.new(connection, 'test_container')
     assert_equal @container.log_retention?, true
   end
   def test_object_fetch
-    build_net_http_object(:code => '204', :response => {'last-modified' => 'Wed, 28 Jan 2009 16:16:26 GMT'})
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:head_object).returns({'last-modified' => 'Wed, 28 Jan 2009 16:16:26 GMT'})
+    @container = CloudFiles::Container.new(connection, "test_container")
     object = @container.object('good_object')
     assert_equal object.class, CloudFiles::StorageObject
   end
   def test_create_object
-    build_net_http_object()
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    @container = CloudFiles::Container.new(connection, "test_container")
     object = @container.create_object('new_object')
     assert_equal object.class, CloudFiles::StorageObject
   end
   def test_object_exists_true
-    build_net_http_object
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:head_object).returns({'last-modified' => 'Wed, 28 Jan 2009 16:16:26 GMT'})
+    @container = CloudFiles::Container.new(connection, "test_container")
     assert_equal @container.object_exists?('good_object'), true
   end
   def test_object_exists_false
-    build_net_http_object(:code => '999')
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:head_object).raises(ClientException.new("test_object_exists_false", :http_status => 404))
+    @container = CloudFiles::Container.new(connection, "test_container")
     assert_equal @container.object_exists?('bad_object'), false
   end
   def test_delete_object_succeeds
-    build_net_http_object
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:delete_object).returns(nil)
+    @container = CloudFiles::Container.new(connection, "test_container")
     assert_nothing_raised do
       @container.delete_object('good_object')
     end
   end
   def test_delete_invalid_object_fails
-    build_net_http_object(:code => '404')
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:delete_object).raises(ClientException.new('test_delete_invalid_object_fails', :http_status => 404))
+    @container = CloudFiles::Container.new(connection, "test_container")
     assert_raise(CloudFiles::Exception::NoSuchObject) do
       @container.delete_object('nonexistent_object')
     end
   end
   def test_delete_invalid_response_code_fails
-    build_net_http_object(:code => '999')
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:delete_object).raises(ClientException.new('test_delete_invalid_object_fails', :http_status => 999))
+    @container = CloudFiles::Container.new(connection, "test_container")
     assert_raise(CloudFiles::Exception::InvalidResponse) do
       @container.delete_object('broken_object')
     end
   end
   def test_fetch_objects
-    build_net_http_object(:code => '200', :body => "foo\nbar\nbaz")
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:get_container).returns([{'x-container-bytes-used' => '10','x-container-object-count' => '1'}, [{'name' => 'foo'},{'name' => 'bar'},{'name' => 'baz'}]])
+    @container = CloudFiles::Container.new(connection, "test_container")
     objects = @container.objects
     assert_equal objects.class, Array
     assert_equal objects.size, 3
     assert_equal objects.first, 'foo'
   end
+  def test_fetch_objects_fails
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:get_container).raises(ClientException.new("test_fetch_object_fails", :http_status => 500))
+    @container = CloudFiles::Container.new(connection, "test_container")
+    assert_raise(CloudFiles::Exception::InvalidResponse) do
+      objects = @container.objects
+    end
+  end
   def test_fetch_objects_with_limit
-    build_net_http_object_with_cfreq_expectations({:code => '200', :body => "foo"},
-                                                  {:path => includes("limit=1")})
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:get_container).returns([{'x-container-bytes-used' => '10','x-container-object-count' => '1'}, [{'name' => 'foo'}]])
+    @container = CloudFiles::Container.new(connection, "test_container")
     objects = @container.objects(:limit => 1)
     assert_equal objects.class, Array
     assert_equal objects.size, 1
@@ -237,8 +302,11 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   def test_fetch_objects_with_marker
-    build_net_http_object_with_cfreq_expectations({:code => '200', :body => "bar"},
-                                                  {:path => includes("marker=foo")})
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:get_container).returns([{'x-container-bytes-used' => '10','x-container-object-count' => '1'}, [{'name' => 'bar'}]])
+    @container = CloudFiles::Container.new(connection, "test_container")
     objects = @container.objects(:marker => 'foo')
     assert_equal objects.class, Array
     assert_equal objects.size, 1
@@ -246,8 +314,11 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   def test_fetch_objects_with_deprecated_offset_param
-    build_net_http_object_with_cfreq_expectations({:code => '200', :body => "bar"},
-                                                  {:path => includes("marker=foo")})
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:get_container).returns([{'x-container-bytes-used' => '10','x-container-object-count' => '1'}, [{'name' => 'bar'}]])
+    @container = CloudFiles::Container.new(connection, "test_container")
     objects = @container.objects(:offset => 'foo')
     assert_equal objects.class, Array
     assert_equal objects.size, 1
@@ -255,108 +326,169 @@ class CloudfilesContainerTest < Test::Unit::TestCase
   end
   def object_detail_body(skip_kisscam=false)
-    lines = ['<?xml version="1.0" encoding="UTF-8"?>',
-             '<container name="video">']
-    unless skip_kisscam
-      lines << '<object><name>kisscam.mov</name><hash>96efd5a0d78b74cfe2a911c479b98ddd</hash><bytes>9196332</bytes><content_type>video/quicktime</content_type><last_modified>2008-12-18T10:34:43.867648</last_modified></object>
->'
-    end
-    lines << '<object><name>penaltybox.mov</name><hash>d2a4c0c24d8a7b4e935bee23080e0685</hash><bytes>24944966</bytes><content_type>video/quicktime</content_type><last_modified>2008-12-18T10:35:19.273927</last_modified></object>'
-    lines << '</container>'
-    lines.join("\n\n")
+    lines = []
+    lines << {'name' => 'kisscam.mov', 'hash' => '96efd5a0d78b74cfe2a911c479b98ddd', 'bytes' => '9196332', 'content_type' => 'video/quicktime', 'last_modified' => '2008-12-18T10:34:43.867648'} unless skip_kisscam
+    lines << {'name' => 'penaltybox.mov', 'hash' => 'd2a4c0c24d8a7b4e935bee23080e0685', 'bytes' => '24944966', 'content_type' => 'video/quicktime', 'last_modified' => '2008-12-18T10:35:19.273927'}
   end
   def test_fetch_objects_detail
-    build_net_http_object(:code => '200', :body => object_detail_body)
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '2'})
+    SwiftClient.stubs(:get_container).returns([{'x-container-bytes-used' => '10','x-container-object-count' => '2'}, object_detail_body])
+    @container = CloudFiles::Container.new(connection, "test_container")
     details = @container.objects_detail
     assert_equal details.size, 2
     assert_equal details['kisscam.mov'][:bytes], '9196332'
   end
   def test_fetch_objects_details_with_limit
-    build_net_http_object_with_cfreq_expectations({:code => '200', :body => object_detail_body},
-                                                  {:path => includes("limit=2")})
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '2'})
+    SwiftClient.stubs(:get_container).returns([{'x-container-bytes-used' => '10','x-container-object-count' => '2'}, object_detail_body])
+    @container = CloudFiles::Container.new(connection, "test_container")
     details = @container.objects_detail(:limit => 2)
     assert_equal details.size, 2
     assert_equal details['kisscam.mov'][:bytes], '9196332'
   end
   def test_fetch_objects_detail_with_marker
-    build_net_http_object_with_cfreq_expectations({:code => '200', :body => object_detail_body(true)},
-                                                  {:path => includes("marker=kisscam.mov")})
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:get_container).returns([{'x-container-bytes-used' => '10','x-container-object-count' => '1'}, object_detail_body(true)])
+    @container = CloudFiles::Container.new(connection, "test_container")
     details = @container.objects_detail(:marker => 'kisscam.mov')
     assert_equal details.size, 1
     assert_equal details['penaltybox.mov'][:bytes], '24944966'
   end
   def test_fetch_objects_detail_with_deprecated_offset_param
-    build_net_http_object_with_cfreq_expectations({:code => '200', :body => object_detail_body(true)},
-                                                  {:path => includes("marker=kisscam.mov")})
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '10','x-container-object-count' => '1'})
+    SwiftClient.stubs(:get_container).returns([{'x-container-bytes-used' => '10','x-container-object-count' => '1'}, object_detail_body(true)])
+    @container = CloudFiles::Container.new(connection, "test_container")
     details = @container.objects_detail(:offset => 'kisscam.mov')
     assert_equal details.size, 1
     assert_equal details['penaltybox.mov'][:bytes], '24944966'
   end
   def test_fetch_object_detail_empty
-    build_net_http_object
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '0'})
+    SwiftClient.stubs(:get_container).returns([{'x-container-bytes-used' => '0','x-container-object-count' => '0'}, {}])
+    @container = CloudFiles::Container.new(connection, "test_container")
     details = @container.objects_detail
     assert_equal details, {}
   end
   def test_fetch_object_detail_error
-    build_net_http_object(:code => '999')
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '0'})
+    SwiftClient.stubs(:get_container).raises(ClientException.new('test_fetch_object_detail_error', :http_status => 999))
+    @container = CloudFiles::Container.new(connection, "test_container")
     assert_raise(CloudFiles::Exception::InvalidResponse) do
       details = @container.objects_detail
     end
   end
   def test_setting_log_retention
-    build_net_http_object(:code => '201', :cdn_request => 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', :cdn_available? => true, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '0'})
+    SwiftClient.stubs(:post_container).returns(true)
+    @container = CloudFiles::Container.new(connection, "test_container")
     assert(@container.log_retention='false')
   end
+  def test_setting_log_retention_fails
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '0'})
+    SwiftClient.stubs(:post_container).raises(ClientException.new("test_setting_log_retention_fails", :http_status => 500))
+    @container = CloudFiles::Container.new(connection, "test_container")
+    assert_raise(CloudFiles::Exception::InvalidResponse) do
+      @container.log_retention='false'
+    end
+  end
   def test_purge_from_cdn_succeeds
-    build_net_http_object(:cdn_request => 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', :cdn_available? => true, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '0'})
+    SwiftClient.stubs(:delete_container).returns(nil)
+    @container = CloudFiles::Container.new(connection, "test_container")
     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={}, cfreq_expectations={})
-    args.merge!(:code => '204') unless args[:code]
-    CloudFiles::Container.any_instance.stubs(:populate).returns(true)
-    CloudFiles::Container.any_instance.stubs(:metadata).returns()
-    CloudFiles::Container.any_instance.stubs(:container_metadata).returns({:bytes => 99, :count => 2})
-    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])
-    response.stubs(:body).returns args[:body] || nil
+  def test_purge_from_cdn_fails
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '0'})
+    SwiftClient.stubs(:delete_container).raises(ClientException.new("test_purge_from_cdn_fails", :http_status => 500))
+    @container = CloudFiles::Container.new(connection, "test_container")
-    if !cfreq_expectations.empty?
-      #cfreq(method,server,path,port,scheme,headers = {},data = nil,attempts = 0,&block)
-      parameter_expectations = [anything(), anything(), anything(), anything(), anything(), anything()]
-      parameter_expectations[0] = cfreq_expectations[:method] if cfreq_expectations[:method]
-      parameter_expectations[1] = cfreq_expectations[:path] if cfreq_expectations[:path]
-      connection.expects(:cdn_request).with(*parameter_expectations).returns(response) if args[:cdn_request]
-      connection.expects(:storage_request).with(*parameter_expectations).returns(response)
-    else
-      connection.stubs(:cdn_request => response) if args[:cdn_request]
-      connection.stubs(:storage_request => response)
+    assert_raise(CloudFiles::Exception::Connection) do
+      @container.purge_from_cdn
     end
-    @container = CloudFiles::Container.new(connection, 'test_container')
-    @container.stubs(:connection).returns(connection)
   end
-  def build_net_http_object_with_cfreq_expectations(args={}, cfreq_expectations={})
-    build_net_http_object(args, cfreq_expectations)
+  def test_cdn_metadata_fails
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '0'})
+    @container = CloudFiles::Container.new(connection, "test_container")
+    SwiftClient.stubs(:head_container).raises(ClientException.new("test_cdn_metadata_fails", :http_status => 404))
+    assert_raise(CloudFiles::Exception::NoSuchContainer) do
+      @container.cdn_metadata
+    end
+  end
+  def test_cdn_metadata_no_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', :cdn_available? => false, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '0'})
+    @container = CloudFiles::Container.new(connection, "test_container")
+    assert_equal @container.cdn_metadata, {}
+  end
+  def test_bytes
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '99','x-container-object-count' => '10'})
+    @container = CloudFiles::Container.new(connection, "test_container")
+    assert_equal @container.bytes, 99
+  end
+  def test_count
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '10'})
+    @container = CloudFiles::Container.new(connection, "test_container")
+    assert_equal @container.count, 10
+  end
+  def test_cdn_ssl_url
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '10', 'x-cdn-ssl-uri' => 'https://ssl.cdn.test.example/container', "x-cdn-enabled" => 'True'})
+    @container = CloudFiles::Container.new(connection, "test_container")
+    assert_equal @container.cdn_ssl_url, 'https://ssl.cdn.test.example/container'
+  end
+  def test_cdn_url
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '10', 'x-cdn-uri' => 'http://cdn.test.example/container', "x-cdn-enabled" => 'True'})
+    @container = CloudFiles::Container.new(connection, "test_container")
+    assert_equal @container.cdn_url, 'http://cdn.test.example/container'
+  end
+  def test_metadata
+    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, :cdnurl => 'http://foo.test.example/container', :storageurl => 'http://foo.test.example/container', :authtoken => "dummy token")
+    SwiftClient.stubs(:head_container).returns({'x-container-bytes-used' => '0','x-container-object-count' => '10', 'x-container-meta-foo' => 'bar'})
+    @container = CloudFiles::Container.new(connection, "test_container")
+    assert_equal @container.metadata, {'foo' => 'bar'}
   end
 end