cloudfiles 1.4.18 → 1.5.0

data/lib/cloudfiles/storage_object.rb

@@ -34,8 +34,11 @@ module CloudFiles
     # Retrieves Metadata for the object
     def object_metadata
       @object_metadata ||= (
-        response = self.container.connection.storage_request("HEAD", @storagepath)
-        raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" unless (response.code =~ /^20/)
+        begin
+          response = SwiftClient.head_object(self.container.connection.storageurl, self.container.connection.authtoken, self.container.escaped_name, (CloudFiles.escape self.name))
+        rescue ClientException => e
+          raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" unless (e.status.to_s =~ /^20/)
+        end
         resphash = {}
         metas = response.to_hash.select { |k,v| k.match(/^x-object-meta/) }
 
@@ -91,9 +94,12 @@ module CloudFiles
         range = sprintf("bytes=%d-%d", offset.to_i, (offset.to_i + size.to_i) - 1)
         headers['Range'] = range
       end
-      response = self.container.connection.storage_request("GET", @storagepath, headers)
-      raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" unless (response.code =~ /^20/)
-      response.body
+      begin
+        response = SwiftClient.get_object(self.container.connection.storageurl, self.container.connection.authtoken, self.container.escaped_name, (CloudFiles.escape self.name))
+        response[1]
+      rescue ClientException => e
+        raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" unless (e.status.to_s =~ /^20/)
+      end
     end
     alias :read :data
 
@@ -115,9 +121,8 @@ module CloudFiles
         range = sprintf("bytes=%d-%d", offset.to_i, (offset.to_i + size.to_i) - 1)
         headers['Range'] = range
       end
-      self.container.connection.storage_request("GET", @storagepath, headers, nil) do |response|
-        raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist. Response code #{response.code}" unless (response.code =~ /^20./)
-        response.read_body(&block)
+      begin
+        SwiftClient.get_object(self.container.connection.storageurl, self.container.connection.authtoken, self.container.escaped_name, (CloudFiles.escape self.name), nil, nil, &block)
       end
     end
 
@@ -140,10 +145,14 @@ module CloudFiles
     def set_metadata(metadatahash)
       headers = {}
       metadatahash.each{ |key, value| headers['X-Object-Meta-' + key.to_s.capitalize] = value.to_s }
-      response = self.container.connection.storage_request("POST", @storagepath, headers)
-      raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" if (response.code == "404")
-      raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code =~ /^20/)
-      true
+      begin
+        SwiftClient.post_object(self.container.connection.storageurl, self.container.connection.authtoken, self.container.escaped_name, (CloudFiles.escape self.name), headers)
+        true
+      rescue ClientException => e
+        raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" if (e.status.to_s == "404")
+        raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{e.status.to_s}" unless (e.status.to_s =~ /^20/)
+        false
+      end
     end
     alias :metadata= :set_metadata
     
@@ -164,10 +173,14 @@ module CloudFiles
     # fails.
     def set_manifest(manifest)
       headers = {'X-Object-Manifest' => manifest}
-      response = self.container.connection.storage_request("PUT", @storagepath, headers)
-      raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" if (response.code == "404")
-      raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code =~ /^20/)
-      true
+      begin
+        SwiftClient.post_object(self.container.connection.storageurl, self.container.connection.authtoken, self.container.escaped_name, (CloudFiles.escape self.name), headers)
+        true
+      rescue ClientException => e
+        raise CloudFiles::Exception::NoSuchObject, "Object #{@name} does not exist" if (response.code == "404")
+        raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code =~ /^20/)
+        false
+      end
     end
 
 
@@ -201,21 +214,16 @@ module CloudFiles
 
     def write(data = nil, headers = {})
       raise CloudFiles::Exception::Syntax, "No data or header updates supplied" if ((data.nil? && $stdin.tty?) and headers.empty?)
-      if headers['Content-Type'].nil?
-        type = MIME::Types.type_for(self.name).first.to_s
-        if type.empty?
-          headers['Content-Type'] = "application/octet-stream"
-        else
-          headers['Content-Type'] = type
-        end
-      end
       # If we're taking data from standard input, send that IO object to cfreq
       data = $stdin if (data.nil? && $stdin.tty? == false)
-      response = self.container.connection.storage_request("PUT", @storagepath, headers, data)
-      code = response.code
-      raise CloudFiles::Exception::InvalidResponse, "Invalid content-length header sent" if (code == "412")
-      raise CloudFiles::Exception::MisMatchedChecksum, "Mismatched etag" if (code == "422")
-      raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{code}" unless (code =~ /^20./)
+      begin
+        response = SwiftClient.put_object(self.container.connection.storageurl, self.container.connection.authtoken, self.container.escaped_name, (CloudFiles.escape self.name), data, nil, nil, nil, nil, headers)
+      rescue ClientException => e
+        code = e.status.to_s
+        raise CloudFiles::Exception::InvalidResponse, "Invalid content-length header sent" if (code == "412")
+        raise CloudFiles::Exception::MisMatchedChecksum, "Mismatched etag" if (code == "422")
+        raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{code}" unless (code =~ /^20./)
+      end
       make_path(File.dirname(self.name)) if @make_path == true
       self.refresh
       true
@@ -241,9 +249,13 @@ module CloudFiles
       raise Exception::CDNNotAvailable unless cdn_available?
       headers = {}
       headers = {"X-Purge-Email" => email} if email
-      response = self.container.connection.cdn_request("DELETE", @storagepath, headers)
-      raise CloudFiles::Exception::Connection, "Error Unable to Purge Object: #{@name}" unless (response.code.to_s =~ /^20.$/)
-      true
+      begin
+        SwiftClient.delete_object(self.container.connection.cdnurl, self.container.connection.authtoken, self.container.escaped_name, (CloudFiles.escape self.name), nil, headers)
+        true
+      rescue ClientException => e
+        raise CloudFiles::Exception::Connection, "Error Unable to Purge Object: #{@name}" unless (e.status.to_s =~ /^20.$/)
+        false
+      end
     end
 
     # A convenience method to stream data into an object from a local file (or anything that can be loaded by Ruby's open method)
@@ -296,6 +308,7 @@ module CloudFiles
     def save_to_filename(filename)
       File.open(filename, 'wb+') do |f|
         self.data_stream do |chunk|
+          puts chunk.length
           f.write chunk
         end
       end
@@ -359,10 +372,13 @@ module CloudFiles
       headers = {'X-Copy-From' => "#{self.container.name}/#{self.name}", 'Content-Type' => self.content_type.sub(/;.+/, '')}.merge(new_headers)
       # , 'Content-Type' => self.content_type
       new_path = "#{CloudFiles.escape new_container}/#{CloudFiles.escape new_name, '/'}"
-      response = self.container.connection.storage_request("PUT", new_path, headers)
-      code = response.code
-      raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code =~ /^20/)
-      return CloudFiles::Container.new(self.container.connection, new_container).object(new_name)
+      begin
+        response = SwiftClient.put_object(self.container.connection.storageurl, self.container.connection.authtoken, (CloudFiles.escape new_container), (CloudFiles.escape new_name), nil, nil, nil, nil, nil, headers)
+        return CloudFiles::Container.new(self.container.connection, new_container).object(new_name)
+      rescue ClientException => e
+        code = e.status.to_s
+        raise CloudFiles::Exception::InvalidResponse, "Invalid response code #{response.code}" unless (response.code =~ /^20/)
+      end
     end
     
     # Takes the same options as the copy method, only it does a copy followed by a delete on the original object.

data/lib/cloudfiles/version.rb

@@ -1,3 +1,3 @@
 module CloudFiles
-  VERSION = '1.4.18'
+  VERSION = '1.5.0'
 end

data/test/cloudfiles_authentication_test.rb

@@ -2,37 +2,25 @@ $:.unshift File.dirname(__FILE__)
 require 'test_helper'
 
 class CloudfilesAuthenticationTest < Test::Unit::TestCase
-  
-
   def test_good_authentication
-    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 = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
-    server.stubs(:get).returns(response)
-    CloudFiles::Authentication.any_instance.stubs(:get_server).returns(server)
-    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true, :snet? => false, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true, :cdn_available= => true)
+    response = ['http://cdn.example.com/storage', 'dummy_token', {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}]
+    SwiftClient.stubs(:get_auth).returns(response)
+    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true, :snet? => false, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true, :cdn_available= => true, :snet => false)
     result = CloudFiles::Authentication.new(@connection)
     assert_equal result.class, CloudFiles::Authentication
   end
   
   def test_snet_authentication
-    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 = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
-    server.stubs(:get).returns(response)
-    CloudFiles::Authentication.any_instance.stubs(:get_server).returns(server)
-    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true, :snet? => true, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true, :cdn_available= => true)
+    response = ['http://cdn.example.com/storage', 'dummy_token', {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}]
+    SwiftClient.stubs(:get_auth).returns(response)
+    @connection = stub(:authuser => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true, :snet? => true, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true, :cdn_available= => true, :snet => true)
     result = CloudFiles::Authentication.new(@connection)
     assert_equal result.class, CloudFiles::Authentication
   end
   
   def test_bad_authentication
-    response = mock()
-    response.stubs(:code).returns('499')
-    server = mock(:use_ssl= => true, :verify_mode= => true, :start => true)
-    server.stubs(:get).returns(response)
-    CloudFiles::Authentication.any_instance.stubs(:get_server).returns(server)
-    @connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true,  :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true)
+    SwiftClient.stubs(:get_auth).returns(nil)
+    @connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true,  :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true, :snet? => false)
     assert_raises(CloudFiles::Exception::Authentication) do
       result = CloudFiles::Authentication.new(@connection)
     end
@@ -40,10 +28,17 @@ class CloudfilesAuthenticationTest < Test::Unit::TestCase
     
   def test_bad_hostname
     Net::HTTP.stubs(:new).raises(CloudFiles::Exception::Connection)
-    @connection = stub(:proxy_host => nil, :proxy_port => nil, :authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true)
+    @connection = stub(:proxy_host => nil, :proxy_port => nil, :authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true, :snet? => false)
     assert_raises(CloudFiles::Exception::Connection) do
       result = CloudFiles::Authentication.new(@connection)
     end
   end
-    
+  
+  def test_authentication_general_exception
+    SwiftClient.stubs(:get_auth).raises(ClientException.new('foobar'))
+    @connection = stub(:proxy_host => nil, :proxy_port => nil, :authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true, :auth_url => 'https://auth.api.rackspacecloud.com/v1.0', :cdn_available? => true, :snet? => false)
+    assert_raises(CloudFiles::Exception::Connection) do 
+      result = CloudFiles::Authentication.new(@connection)
+    end
+  end
 end

data/test/cloudfiles_client_test.rb

@@ -0,0 +1,797 @@
+$:.unshift File.dirname(__FILE__)
+require 'test_helper'
+
+class SwiftClientTest < Test::Unit::TestCase
+  
+  def setup
+    @url = "http://foo.bar:1234/auth/v1.0"
+    @user = "foo_user"
+    @key = "foo_key"
+    @token = 'foo_token'
+    Net::HTTP.any_instance.stubs(:new).stubs({:port => 1234, :address => 'foo.bar', :class => Net::HTTP})
+    @parsed, @conn = SwiftClient.http_connection(@url)
+  end
+  
+  def test_client_exception
+    foo = ClientException.new("foobar", :http_status => "404")
+    assert_equal "foobar  404", foo.to_s
+  end
+  
+  def test_chunked_connection_wrapper
+    file = mock("File")
+    file.stubs(:read).returns("this ", "is so", "me da", "ta!", "")
+    file.stubs(:eof?).returns(true)
+    file.stubs(:eof!).returns(true)
+    chunk = ChunkedConnectionWrapper.new(file, 5)
+    assert_equal "this ", chunk.read(123)
+    assert_equal "is so", chunk.read(123)
+    assert_equal "me da", chunk.read(123)
+    assert_equal "ta!", chunk.read(123)
+    assert_equal true, chunk.eof?
+    assert_equal true, chunk.eof!
+  end
+  
+  def test_query
+    query = Query.new("foo=bar&baz=quu")
+    query.add("chunky", "bacon")
+    assert_equal "chunky=bacon&baz=quu&foo=bar", query.to_s
+    assert query.has_key? "chunky"
+    query.delete("chunky")
+    assert_equal false, query.has_key?("chunky")
+  end
+  
+  def test_http_connection
+    parsed, conn = SwiftClient.http_connection("http://foo.bar:1234/auth/v1.0")
+    assert_equal 'http', parsed.scheme
+    assert_equal 1234, parsed.port
+    assert_equal 'foo.bar', parsed.host
+    assert_equal '/auth/v1.0', parsed.path
+    assert_equal 'foo.bar', conn.address
+    assert_equal 1234, conn.port
+    assert_equal Net::HTTP, conn.class
+  end
+  
+  def test_http_connection_with_ssl
+    parsed, conn = SwiftClient.http_connection("https://foo.bar:443/auth/v1.0")
+    assert_equal 'https', parsed.scheme
+    assert_equal 443, parsed.port
+    assert_equal 'foo.bar', parsed.host
+    assert_equal '/auth/v1.0', parsed.path
+    assert_equal 'foo.bar', conn.address
+    assert_equal 443, conn.port
+    assert_equal Net::HTTP, conn.class
+    assert_equal true, conn.use_ssl?
+    assert_equal OpenSSL::SSL::VERIFY_NONE, conn.verify_mode
+  end
+  
+  def test_http_connection_with_bad_scheme
+    assert_raises(ClientException) do 
+      parsed, conn = SwiftClient.http_connection("ftp://foo.bar:443/auth/v1.0")
+    end
+  end
+  
+  def test_auth
+    response = stub(
+      :code => "200", 
+      :header => {'x-storage-url' => 'http://foo.bar:1234/v1/AUTH_test', 'x-storage-token' => 'AUTH_test', 'x-auth-token' => 'AUTH_test', 'content-length' => 0, 'date' => 'Tue, 11 Oct 2011 20:54:06 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      storage_url, token, headers = SwiftClient.get_auth(@url, @user, @key)
+      assert_equal "http://foo.bar:1234/v1/AUTH_test", storage_url
+      assert_equal 'AUTH_test', token
+    end
+  end
+  
+  def test_auth_with_snet
+    response = stub(
+      :code => "200", 
+      :header => {'x-storage-url' => 'http://foo.bar:1234/v1/AUTH_test', 'x-storage-token' => 'AUTH_test', 'x-auth-token' => 'AUTH_test', 'content-length' => 0, 'date' => 'Tue, 11 Oct 2011 20:54:06 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      storage_url, token, headers = SwiftClient.get_auth(@url, @user, @key, true)
+      assert_equal "http://snet-foo.bar:1234/v1/AUTH_test", storage_url
+      assert_equal 'AUTH_test', token
+    end
+  end
+  
+  def test_auth_fails
+    response = stub(:code => '500', :message => "Internal Server Error")
+    conn = mock("Net::HTTP")
+    conn.stubs(:address).returns('foobar.com')
+    conn.stubs(:port).returns(123)
+    conn.stubs(:started?).returns(false)
+    conn.stubs(:start).returns(nil)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_raise(ClientException) do 
+      SwiftClient.get_auth(@url, @user, @key)
+    end
+  end
+  
+  #test HEAD account
+  def test_head_account
+    response = stub(
+      :code => "200", 
+      :header => {'x-account-object-count' => 123, 'x-account-bytes-used' => 123456, 'x-account-container-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:head).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers = SwiftClient.head_account(@url, @token)
+      assert_equal headers['x-account-object-count'], 123
+      assert_equal headers['x-account-bytes-used'], 123456
+      assert_equal headers['x-account-container-count'], 12
+    end
+  end
+  
+  def test_head_account_fail
+    response = stub(
+      :code => "500",
+      :message => "Internal Error" 
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:head).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_raise(ClientException) do 
+      headers = SwiftClient.head_account(@url, @token)
+    end
+  end
+  
+  #test GET account
+  def test_get_account
+    response = stub(
+      :code => "200", 
+      :body => '[ { "name":".CDN_ACCESS_LOGS", "count":1, "bytes":1234 }, { "name":"First", "count":2, "bytes":2345 }, { "name":"Second", "count":3, "bytes":3456 }, { "name":"Third", "count":4, "bytes":4567 } ]', 
+      :header => {'x-account-object-count' => 123, 'x-account-bytes-used' => 123456, 'x-account-container-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers, result = SwiftClient.get_account(@url, @token)
+      assert_equal headers, response.header
+      assert_equal result, JSON.parse(response.body)
+    end
+  end
+  
+  def test_get_account_no_content
+    response = stub(
+      :code => "204", 
+      :body => nil, 
+      :header => {'x-account-object-count' => 123, 'x-account-bytes-used' => 123456, 'x-account-container-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers, result = SwiftClient.get_account(@url, @token)
+      assert_equal headers, response.header
+      assert_equal result, []
+    end
+  end
+  
+  def test_get_account_marker
+    response = stub(
+      :code => "200", 
+      :body => '[ { "name":"Second", "count":3, "bytes":3456 }, { "name":"Third", "count":4, "bytes":4567 } ]', 
+      :header => {'x-account-object-count' => 123, 'x-account-bytes-used' => 123456, 'x-account-container-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers, result = SwiftClient.get_account(@url, @token, "First")
+      assert_equal headers, response.header
+      assert_equal result, JSON.parse(response.body)
+    end
+  end
+  
+  def test_get_account_limit
+    response = stub(
+      :code => "200", 
+      :body => '[ { "name":".CDN_ACCESS_LOGS", "count":1, "bytes":1234 }, { "name":"First", "count":2, "bytes":2345 } ]', 
+      :header => {'x-account-object-count' => 123, 'x-account-bytes-used' => 123456, 'x-account-container-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers, result = SwiftClient.get_account(@url, @token, nil, 2)
+      assert_equal headers, response.header
+      assert_equal result, JSON.parse(response.body)
+    end
+  end
+  
+  def test_get_account_prefix
+    response = stub(
+      :code => "200", 
+      :body => '[ { "name":"First", "count":2, "bytes":2345 } ]', 
+      :header => {'x-account-object-count' => 123, 'x-account-bytes-used' => 123456, 'x-account-container-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers, result = SwiftClient.get_account(@url, @token, nil, nil, "F")
+      assert_equal headers, response.header
+      assert_equal result, JSON.parse(response.body)
+    end
+  end
+  
+  def test_get_account_full_listing
+    response1 = stub(
+      :code => "200", 
+      :body => '[ { "name":".CDN_ACCESS_LOGS", "count":1, "bytes":1234 }, { "name":"First", "count":2, "bytes":2345 }, { "name":"Second", "count":3, "bytes":3456 }, { "name":"Third", "count":4, "bytes":4567 } ]', 
+      :header => {'x-account-object-count' => 123, 'x-account-bytes-used' => 123456, 'x-account-container-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    response2 = stub(
+      :code => "200", 
+      :body => '[ { "name":"Fourth", "count":1, "bytes":1234 }, { "name":"Fifth", "count":2, "bytes":2345 }, { "name":"Sixth", "count":3, "bytes":3456 }, { "name":"Seventh", "count":4, "bytes":4567 } ]', 
+      :header => {'x-account-object-count' => 123, 'x-account-bytes-used' => 123456, 'x-account-container-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    response3 = stub(
+      :code => "200", 
+      :body => '[]', 
+      :header => {'x-account-object-count' => 123, 'x-account-bytes-used' => 123456, 'x-account-container-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).at_least(3).at_most(3).returns(response1, response2, response3)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers, result = SwiftClient.get_account(@url, @token, nil, nil, nil, nil, true)
+      assert_equal headers, response1.header
+      assert_equal JSON.parse(response1.body) + JSON.parse(response2.body) + JSON.parse(response3.body), result
+    end
+  end
+  
+  def test_get_account_fail
+    response = stub(
+      :code => "500",
+      :message => "Internal Error"
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_raise(ClientException) do 
+      headers = SwiftClient.get_account(@url, @token)
+    end
+  end
+  
+  #test POST account
+  def test_post_account
+    response = stub(:code => 204, :body => nil)
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:post).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      SwiftClient.post_account(@url, @token, {"foo" => "bar"})
+    end    
+  end
+  
+  def test_post_account_fail
+    response = stub(
+      :code => "500",
+      :message => "Internal Error"
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:post).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_raise(ClientException) do 
+      headers = SwiftClient.post_account(@url, @token, {"foo" => "bar"})
+    end
+  end
+  
+  #test HEAD container
+  def test_head_container
+    response = stub(
+      :code => "204", 
+      :header => {'x-container-object-count' => 6, 'x-container-meta-baz' => 'que', 'x-container-meta-foo' => 'bar', 'x-container-bytes-used' => 123456, 'accept-ranges' => 'bytes', 'content-length' => 83, 'content-type' => 'text/plain; charset=utf-8', 'x-trans-id' => 'txfoo123', 'date' => 'Thu, 13 Oct 2011 22:29:14 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:head).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers = SwiftClient.head_container(@url, @token, 'test_container')
+      assert_equal headers, response.header
+    end
+  end
+  
+  def test_head_container_fail
+    response = stub(:code => "500", :message => "failed")
+    conn = mock("Net::HTTP")
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:head).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_raise(ClientException) do
+      headers, result = SwiftClient.head_container(@url, @token, 'test_container')
+    end
+  end
+  
+  #test GET container
+  def test_get_container
+    response = stub(
+      :code => "200", 
+      :header => {'x-container-object-count' => 6, 'x-container-meta-baz' => 'que', 'x-container-meta-foo' => 'bar', 'x-container-bytes-used' => 123456, 'accept-ranges' => 'bytes', 'content-length' => 83, 'content-type' => 'text/plain; charset=utf-8', 'x-trans-id' => 'txfoo123', 'date' => 'Thu, 13 Oct 2011 22:29:14 GMT'}, 
+      :body => '[ { "name":"foo.mp4", "hash":"foo_hash", "bytes":1234567, "content_type":"video/mp4", "last_modified":"2011-06-21T19:49:06.607670" }, { "name":"bar.ogv", "hash":"bar_hash", "bytes":987654, "content_type":"video/ogg", "last_modified":"2011-06-21T19:48:57.504050" }, { "name":"baz.webm", "hash":"baz_hash", "bytes":1239874, "content_type":"application/octet-stream", "last_modified":"2011-06-21T19:48:43.923990" }, { "name":"fobarbaz.html", "hash":"foobarbaz_hash", "bytes":12893467, "content_type":"text/html", "last_modified":"2011-06-21T19:54:36.555070" } ]'
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers, result = SwiftClient.get_container(@url, @token, 'test_container')
+      assert_equal headers, response.header
+      assert_equal result, JSON.parse(response.body)
+    end
+  end
+  
+  
+  def test_get_container_no_content
+    response = stub(
+      :code => "204", 
+      :body => nil, 
+      :header => {'x-container-object-count' => 123, 'x-container-bytes-used' => 123456, 'x-container-object-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers, result = SwiftClient.get_container(@url, @token, 'test_container')
+      assert_equal headers, response.header
+      assert_equal result, []
+    end
+  end
+  
+  def test_get_container_marker
+    response = stub(
+      :code => "200", 
+      :body => '[ { "name":"bar.ogv", "hash":"bar_hash", "bytes":987654, "content_type":"video/ogg", "last_modified":"2011-06-21T19:48:57.504050" }, { "name":"baz.webm", "hash":"baz_hash", "bytes":1239874, "content_type":"application/octet-stream", "last_modified":"2011-06-21T19:48:43.923990" }, { "name":"fobarbaz.html", "hash":"foobarbaz_hash", "bytes":12893467, "content_type":"text/html", "last_modified":"2011-06-21T19:54:36.555070" } ]',
+      :header => {'x-container-object-count' => 123, 'x-container-bytes-used' => 123456, 'x-container-object-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers, result = SwiftClient.get_container(@url, @token, "test_container", "foo.mp4")
+      assert_equal headers, response.header
+      assert_equal result, JSON.parse(response.body)
+    end
+  end
+  
+  def test_get_container_limit
+    response = stub(
+      :code => "200", 
+      :body => '[ { "name":"foo.mp4", "hash":"foo_hash", "bytes":1234567, "content_type":"video/mp4", "last_modified":"2011-06-21T19:49:06.607670" }, { "name":"bar.ogv", "hash":"bar_hash", "bytes":987654, "content_type":"video/ogg", "last_modified":"2011-06-21T19:48:57.504050" } ]',
+      :header => {'x-container-object-count' => 123, 'x-container-bytes-used' => 123456, 'x-container-object-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers, result = SwiftClient.get_container(@url, @token, 'test_container', nil, 2)
+      assert_equal headers, response.header
+      assert_equal result, JSON.parse(response.body)
+      assert_equal result.length, 2
+    end
+  end
+  
+  def test_get_container_prefix
+    response = stub(
+      :code => "200", 
+      :body => '[ { "name":"bar.ogv", "hash":"bar_hash", "bytes":987654, "content_type":"video/ogg", "last_modified":"2011-06-21T19:48:57.504050" }, { "name":"baz.webm", "hash":"baz_hash", "bytes":1239874, "content_type":"application/octet-stream", "last_modified":"2011-06-21T19:48:43.923990" }]',
+      :header => {'x-container-object-count' => 123, 'x-container-bytes-used' => 123456, 'x-container-object-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'}
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers, result = SwiftClient.get_container(@url, @token, 'test_container', nil, nil, "b")
+      assert_equal headers, response.header
+      assert_equal result, JSON.parse(response.body)
+    end
+  end
+
+  def test_get_container_full_listing
+    response1 = stub(
+      :code => "200", 
+      :header => {'x-container-object-count' => 6, 'x-container-meta-baz' => 'que', 'x-container-meta-foo' => 'bar', 'x-container-bytes-used' => 123456, 'accept-ranges' => 'bytes', 'content-length' => 83, 'content-type' => 'text/plain; charset=utf-8', 'x-trans-id' => 'txfoo123', 'date' => 'Thu, 13 Oct 2011 22:29:14 GMT'}, 
+      :body => '[ { "name":"foo.mp4", "hash":"foo_hash", "bytes":1234567, "content_type":"video/mp4", "last_modified":"2011-06-21T19:49:06.607670" }, { "name":"bar.ogv", "hash":"bar_hash", "bytes":987654, "content_type":"video/ogg", "last_modified":"2011-06-21T19:48:57.504050" }, { "name":"baz.webm", "hash":"baz_hash", "bytes":1239874, "content_type":"application/octet-stream", "last_modified":"2011-06-21T19:48:43.923990" }, { "name":"fobarbaz.html", "hash":"foobarbaz_hash", "bytes":12893467, "content_type":"text/html", "last_modified":"2011-06-21T19:54:36.555070" } ]'
+    )
+    response2 = stub(
+      :code => "200", 
+      :header => {'x-container-object-count' => 6, 'x-container-meta-baz' => 'que', 'x-container-meta-foo' => 'bar', 'x-container-bytes-used' => 123456, 'accept-ranges' => 'bytes', 'content-length' => 83, 'content-type' => 'text/plain; charset=utf-8', 'x-trans-id' => 'txfoo123', 'date' => 'Thu, 13 Oct 2011 22:29:14 GMT'}, 
+      :body => '[ { "name":"foo2.mp4", "hash":"foo_hash", "bytes":1234567, "content_type":"video/mp4", "last_modified":"2011-06-21T19:49:06.607670" }, { "name":"bar2.ogv", "hash":"bar_hash", "bytes":987654, "content_type":"video/ogg", "last_modified":"2011-06-21T19:48:57.504050" }, { "name":"baz2.webm", "hash":"baz_hash", "bytes":1239874, "content_type":"application/octet-stream", "last_modified":"2011-06-21T19:48:43.923990" }, { "name":"fobarbaz2.html", "hash":"foobarbaz_hash", "bytes":12893467, "content_type":"text/html", "last_modified":"2011-06-21T19:54:36.555070" } ]'
+    )
+    response3 = stub(
+      :code => "200", 
+      :header => {'x-container-object-count' => 6, 'x-container-meta-baz' => 'que', 'x-container-meta-foo' => 'bar', 'x-container-bytes-used' => 123456, 'accept-ranges' => 'bytes', 'content-length' => 83, 'content-type' => 'text/plain; charset=utf-8', 'x-trans-id' => 'txfoo123', 'date' => 'Thu, 13 Oct 2011 22:29:14 GMT'}, 
+      :body => '[]'
+    )
+    
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).at_least(3).at_most(3).returns(response1, response2, response3)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers, result = SwiftClient.get_container(@url, @token, 'test_container', nil, nil, nil, nil, nil, true)
+      assert_equal headers, response1.header
+      assert_equal JSON.parse(response1.body) + JSON.parse(response2.body) + JSON.parse(response3.body), result
+    end
+  end
+  
+  def test_get_container_fail
+    response = stub(:code => "500", :message => "failed")
+    conn = mock("Net::HTTP")
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_raise(ClientException) do
+      headers, result = SwiftClient.get_container(@url, @token, 'test_container')
+    end
+  end
+  
+  #test PUT container
+  def test_put_container
+    response = stub(:code => "200")
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:put).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_nothing_raised do
+      headers, result = SwiftClient.put_container(@url, @token, 'test_container')
+    end
+  end
+  
+  def test_put_container_fail
+    response = stub(:code => "500", :message => "failed")
+    conn = mock("Net::HTTP")
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:put).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_raise(ClientException) do
+      headers, result = SwiftClient.put_container(@url, @token, 'test_container')
+    end
+  end
+  
+  #test POST container
+  def test_post_container
+    response = stub(:code => "200")
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:post).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_nothing_raised do
+      headers, result = SwiftClient.post_container(@url, @token, 'test_container', {'x-container-metadata-foo' => 'bar'})
+    end
+  end
+  
+  def test_post_container_fail
+    response = stub(:code => "500", :message => "failed")
+    conn = mock("Net::HTTP")
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:post).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_raise(ClientException) do
+      headers, result = SwiftClient.post_container(@url, @token, 'test_container', {'x-container-metadata-foo' => 'bar'})
+    end
+  end
+  
+  #test DELETE container
+  def test_delete_container
+    response = stub(:code => "200", :body => "")
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:delete).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_nothing_raised do
+      SwiftClient.delete_container(@url, @token, 'test_container')
+    end
+  end
+
+  def test_delete_container_fails
+    response = stub(:code => "500", :message => "failed")
+    conn = mock("Net::HTTP")
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:delete).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_raise(ClientException) do
+      SwiftClient.delete_container(@url, @token, 'test_container')
+    end
+  end
+    
+  #test HEAD object
+  def test_head_object
+    response = stub(:code => "204", :header => {'etag' => 'etag_foobarbaz', 'accept-ranges' => 'bytes', 'content-length' => 67773, 'content-type' => 'application/javascript', 'x-trans-id' => 'txfoobar', 'date' => 'Fri, 14 Oct 2011 01:21:42 GMT'})
+    conn = mock("Net::HTTP")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:head).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_nothing_raised do
+      headers = SwiftClient.head_object(@url, @token, 'test_container', 'test_object')
+      assert response.header, headers
+    end
+  end
+  
+  def test_head_object_fails
+    response = stub(:code => "500", :message => "failed")
+    conn = mock("Net::HTTP")
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:head).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_raise(ClientException) do
+      headers = SwiftClient.head_object(@url, @token, 'test_container', 'test_object')
+    end
+  end
+  
+  #test GET object
+  def test_get_object
+    response = stub(
+      :code => "200",
+      :header => {'etag' => 'etag_foobarbaz', 'accept-ranges' => 'bytes', 'content-length' => 67773, 'content-type' => 'application/javascript', 'x-trans-id' => 'txfoobar', 'date' => 'Fri, 14 Oct 2011 01:21:42 GMT'},
+      :body => "this is the body"
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:request_get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_nothing_raised do 
+      headers, body = SwiftClient.get_object(@url, @token, 'test_container', 'test_object')
+      assert_equal response.header, headers
+      assert_equal body, "this is the body"
+    end
+  end
+  
+  def test_get_object_fails
+    response = stub(:code => "404", :message => "object not found", :body => "")
+    conn = mock("Net::HTTP")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:request_get).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    
+    assert_raise(ClientException) do
+      headers, body = SwiftClient.get_object(@url, @token, 'test_container', 'test_object')
+    end
+  end
+  
+  #test PUT object
+  def test_put_object
+    response = stub(
+      :code => "201", 
+      :header => {"Content-Length" => 118, "Content-Type" => "text/html; charset=UTF-8", "Etag" => "asfasdfsdafasd2313241ukyhuyhj", "X-Trans-Id" => "txfoo1231231231232123"}, 
+      :message => "created", 
+      :body => ""
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:put).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      SwiftClient.put_object(@url, @token, 'test_container', 'test_object', 'some data to put', 16)
+    end
+  end
+  
+  def test_put_object_fails
+    response = stub(
+      :code => "500", 
+      :message => "internal server error", 
+      :body => ""
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:put).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_raise(ClientException) do
+      SwiftClient.put_object(@url, @token, 'test_container', 'test_object', 'some data to put', 16)
+    end
+  end
+  
+  #test POST object
+  def test_post_object
+    response = stub(
+      :code => "201", 
+      :header => {"Content-Length" => 118, "Content-Type" => "text/html; charset=UTF-8", "Etag" => "asfasdfsdafasd2313241ukyhuyhj", "X-Trans-Id" => "txfoo1231231231232123", "X-Object-Meta-Foo" => "Bar"}, 
+      :message => "created", 
+      :body => ""
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:post).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      headers = SwiftClient.post_object(@url, @token, 'test_container', 'test_object', {"Foo" => "Bar"})
+    end
+  end
+  
+  def test_post_object_fails
+    response = stub(
+      :code => "404", 
+      :message => "no such object", 
+      :body => ""
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:post).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_raise(ClientException) do
+      SwiftClient.post_object(@url, @token, 'test_container', 'test_object', {"foo" => "bar"})
+    end
+  end
+
+  #test DELETE object
+  def test_delete_object
+    response = stub(
+      :code => "204", 
+      :message => "no content",
+      :body => ""
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:delete).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_nothing_raised do
+      SwiftClient.delete_object(@url, @token, 'test_container', 'test_object')
+    end
+  end
+  
+  def test_delete_object_fails
+    response = stub(
+      :code => "404", 
+      :message => "no such object",
+      :body => ""
+    )
+    conn = mock("Net::HTTP")
+    conn.stubs(:port).returns(123)
+    conn.stubs(:address).returns("foobar.com")
+    conn.stubs(:started?).returns(true)
+    conn.stubs(:delete).returns(response)
+    SwiftClient.expects(:http_connection).returns([@parsed, conn])
+    assert_raise(ClientException) do
+      SwiftClient.delete_object(@url, @token, 'test_container', 'test_object')
+    end
+  end
+  
+  def test_retry_failse
+    auth_response = ['http://foo.bar:1234/v1/AUTH_test', 'AUTH_test', {'x-storage-url' => 'http://foo.bar:1234/v1/AUTH_test', 'x-storage-token' => 'AUTH_test', 'x-auth-token' => 'AUTH_test', 'content-length' => 0, 'date' => 'Tue, 11 Oct 2011 20:54:06 GMT'}]
+    SwiftClient.expects(:get_auth).returns(auth_response)
+    SwiftClient.any_instance.stubs(:http_connection).raises(ClientException.new("foobar"))
+    sc = SwiftClient.new(@url, @user, @key)
+    sc.get_auth
+    assert_raise(ClientException) do 
+      sc.get_container("test_container")
+    end
+  end
+
+  def test_oop_swiftclient
+    auth_response = ['http://foo.bar:1234/v1/AUTH_test', 'AUTH_test', {'x-storage-url' => 'http://foo.bar:1234/v1/AUTH_test', 'x-storage-token' => 'AUTH_test', 'x-auth-token' => 'AUTH_test', 'content-length' => 0, 'date' => 'Tue, 11 Oct 2011 20:54:06 GMT'}]
+    account_response = [
+      {'x-account-object-count' => 123, 'x-account-bytes-used' => 123456, 'x-account-container-count' => 12, 'accept-ranges' => 'bytes', 'content-length' => 12345, 'content-type' => 'application/json; charset=utf-8', 'x-trans-id' => 'txfoobar', 'date' => 'Thu, 13 Oct 2011 21:04:14 GMT'},
+      JSON.parse('[ { "name":".CDN_ACCESS_LOGS", "count":1, "bytes":1234 }, { "name":"First", "count":2, "bytes":2345 }, { "name":"Second", "count":3, "bytes":3456 }, { "name":"Third", "count":4, "bytes":4567 } ]')
+    ]
+    container_response = [
+      {'x-container-object-count' => 6, 'x-container-meta-baz' => 'que', 'x-container-meta-foo' => 'bar', 'x-container-bytes-used' => 123456, 'accept-ranges' => 'bytes', 'content-length' => 83, 'content-type' => 'text/plain; charset=utf-8', 'x-trans-id' => 'txfoo123', 'date' => 'Thu, 13 Oct 2011 22:29:14 GMT'}, 
+      JSON.parse('[ { "name":"foo.mp4", "hash":"foo_hash", "bytes":1234567, "content_type":"video/mp4", "last_modified":"2011-06-21T19:49:06.607670" }, { "name":"bar.ogv", "hash":"bar_hash", "bytes":987654, "content_type":"video/ogg", "last_modified":"2011-06-21T19:48:57.504050" }, { "name":"baz.webm", "hash":"baz_hash", "bytes":1239874, "content_type":"application/octet-stream", "last_modified":"2011-06-21T19:48:43.923990" }, { "name":"fobarbaz.html", "hash":"foobarbaz_hash", "bytes":12893467, "content_type":"text/html", "last_modified":"2011-06-21T19:54:36.555070" } ]')
+    ]
+    object_response = [
+      {'Last-Modified' => 'Tue, 01 Jan 2011 00:00:01 GMT', 'Etag' => 'somelarge123hashthingy123foobar', 'Accept-Ranges' => 'bytes', 'Content-Length' => 29, 'Content-Type' => 'application/x-www-form-urlencoded', 'X-Trans-Id' => 'txffffffff00000001231231232112321', 'Date' => 'Tue, 01 Jan 2011 00:00:02 GMT', 'foo' => 'bar'},
+      "some data that is from swift"
+    ]
+    SwiftClient.expects(:http_connection).returns(Net::HTTPExceptions, [@parsed, @conn])
+    SwiftClient.expects(:get_auth).returns(auth_response)
+    SwiftClient.expects(:get_account).returns(account_response)
+    SwiftClient.expects(:head_account).returns(account_response[0])
+    SwiftClient.expects(:post_account).returns(nil)
+    SwiftClient.expects(:get_container).returns(container_response)
+    SwiftClient.expects(:head_container).returns(container_response[0])
+    SwiftClient.expects(:put_container).returns(nil)
+    SwiftClient.expects(:post_container).returns(nil)
+    SwiftClient.expects(:delete_container).returns(nil)
+    SwiftClient.expects(:get_object).returns(object_response)
+    SwiftClient.expects(:head_object).returns(object_response[0])
+    SwiftClient.expects(:put_object).returns(nil)
+    SwiftClient.expects(:post_object).returns(nil)
+    SwiftClient.expects(:delete_object).returns(nil)
+    
+    assert_nothing_raised do
+      sc = SwiftClient.new(@url, @user, @key)
+      #test account
+      sc.get_auth
+      get_a   = sc.get_account
+      assert_equal 123456, get_a[0]['x-account-bytes-used']
+      assert_equal 123, get_a[0]['x-account-object-count']
+      assert_equal 'First', get_a[1][1]['name']
+      head_a  = sc.head_account
+      assert_equal 123456, head_a['x-account-bytes-used']
+      assert_equal 123, head_a['x-account-object-count']
+      sc.post_account({'foo'=>'bar'})
+      #test container
+      get_c   = sc.get_container('test_container')
+      assert_equal 'foo.mp4', get_c[1][0]['name']
+      assert_equal 6, get_c[0]['x-container-object-count']
+      assert_equal 'bar', get_c[0]['x-container-meta-foo']
+      head_c  = sc.head_container('test_container')
+      assert_equal 6, head_c['x-container-object-count']
+      assert_equal 'bar', head_c['x-container-meta-foo']
+      sc.put_container('test_container')
+      sc.post_container('test_container', {'foo' => 'bar'})
+      sc.delete_container('test_container')
+      #test object
+      get_o   = sc.get_object('test_container', 'test_object')
+      assert_equal "some data that is from swift", get_o[1] 
+      assert_equal "somelarge123hashthingy123foobar", get_o[0]['Etag']
+      head_o  = sc.head_object('test_container', 'test_object')
+      assert_equal "somelarge123hashthingy123foobar", head_o['Etag']
+      sc.put_object('test_container', 'test_object', 'some data to put up')
+      sc.post_object('test_container', 'test_object', {"foo" => "bar"})
+      sc.delete_object('test_container', 'test_object')
+    end
+  end
+end