cloudfiles 1.4.18 → 1.5.0

data/test/cloudfiles_connection_test.rb

@@ -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

@@ -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