swift_client 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4555d9e6b744150b80127f8a144e358666a4d70c
-  data.tar.gz: f6da1e97fa79dc31ee538f5c3fa08981d9e76c06
+SHA256:
+  metadata.gz: e91d8e86490003310183e57091645c64e9e4b4a4462b99c82d9a804887a8e2a1
+  data.tar.gz: e826b43a18119d2c9057bc1ed9bcbaf774fc505d7c5313b9ec0fecdbfa1a3d55
 SHA512:
-  metadata.gz: 34f5162ea5b2b2fcfa3f5647eaf8c2d31dbf8947678a32cb8f6c0134f299c63a6c1b89b5c85a19c82d660bb0510ac48bbdd25e5247aa41b00a632b99e9d29ec2
-  data.tar.gz: 570eaee9130d6c3bd43af82dabe763ab8af06b60add3fc577d805ddeb28623889c50de51c1bd28efad0e6edc2f2e04b8dd6461e760a4eb0a6674cb20e92d5b7c
+  metadata.gz: 429ea5bbf5892ac978d33f633bd7aa5fcb2352d18c6f1d76e69af21a36ad97dc2fb7f08fc08427d39c0e08fb59a80f1591481d52723e3efcf6755ccda7ed02d4
+  data.tar.gz: 333a4e6328fd0b0185aca83fddfd5b07628917b2139148bdbca30ffb425e8eb8fb7600d181edc3d40ec5c0f6428dbdba48fcb6d9045ccc57175d14f64f16c862

data/.gitignore

@@ -12,3 +12,4 @@
 *.o
 *.a
 mkmf.log
+.ruby-version

data/.travis.yml

@@ -1,9 +1,8 @@
 
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.7
-  - 2.2.3
+  - 2.1.10
+  - 2.2.5
+  - 2.3.1
 
 install:
   - "travis_retry bundle install"

data/README.md

@@ -101,7 +101,8 @@ swift_client = SwiftClient.new(
   :auth_url => "https://auth.example.com/v3",
   :storage_url => "https://storage.example.com/v1/AUTH_account",
   :user_id => "user id",
-  :password => "password"
+  :password => "password",
+  :interface => "internal"
 )
 
 # OR
@@ -126,26 +127,80 @@ access the response body and JSON response. Checkout the
 
 SwiftClient offers the following requests:
 
-* head_account -> HTTParty::Response
-* post_account(headers = {}) -> HTTParty::Response
-* head_containers -> HTTParty::Response
-* get_containers(query = {}) -> HTTParty::Response
-* paginate_containers(query = {}) -> Enumerator
-* get_container(container_name, query = {}) -> HTTParty::Response
-* paginate_container(container_name, query = {}) -> Enumerator
-* head_container(container_name) -> HTTParty::Response
-* put_container(container_name, headers = {}) -> HTTParty::Response
-* post_container(container_name, headers = {}) -> HTTParty::Response
-* delete_container(container_name) -> HTTParty::Response
-* put_object(object_name, data_or_io, container_name, headers = {}) -> HTTParty::Response
-* post_object(object_name, container_name, headers = {}) -> HTTParty::Response
-* get_object(object_name, container_name) -> HTTParty::Response
-* head_object(object_name, container_name) -> HTTParty::Response
-* delete_object(object_name, container_name) -> HTTParty::Response
-* get_objects(container_name, query = {}) -> HTTParty::Response
-* paginate_objects(container_name, query = {}) -> Enumerator
-* public_url(object_name, container_name) -> HTTParty::Response
-* temp_url(object_name, container_name, options = {}) -> HTTParty::Response
+* `head_account(options = {}) # => HTTParty::Response`
+* `post_account(headers = {}, options = {}) # => HTTParty::Response`
+* `head_containers(options = {}) # => HTTParty::Response`
+* `get_containers(query = {}, options = {}) # => HTTParty::Response`
+* `paginate_containers(query = {}, options = {}) # => Enumerator`
+* `get_container(container_name, query = {}, options = {}) # => HTTParty::Response`
+* `paginate_container(container_name, query = {}, options = {}) # => Enumerator`
+* `head_container(container_name, options = {}) # => HTTParty::Response`
+* `put_container(container_name, headers = {}, options = {}) # => HTTParty::Response`
+* `post_container(container_name, headers = {}, options = {}) # => HTTParty::Response`
+* `delete_container(container_name, options = {}) # => HTTParty::Response`
+* `put_object(object_name, data_or_io, container_name, headers = {}, options = {}) # => HTTParty::Response`
+* `post_object(object_name, container_name, headers = {}, options = {}) # => HTTParty::Response`
+* `get_object(object_name, container_name, options = {}) -> HTTParty::Response`
+* `get_object(object_name, container_name, options = {}) { |chunk| save chunk } # => HTTParty::Response`
+* `head_object(object_name, container_name, options = {}) # => HTTParty::Response`
+* `delete_object(object_name, container_name, options = {}) # => HTTParty::Response`
+* `get_objects(container_name, query = {}, options = {}) # => HTTParty::Response`
+* `paginate_objects(container_name, query = {}, options = {}) # => Enumerator`
+* `public_url(object_name, container_name) # => HTTParty::Response`
+* `temp_url(object_name, container_name, options = {}) # => HTTParty::Response`
+* `bulk_delete(entries, options = {}) # => entries`
+* `post_head(object_name, container_name, _headers = {}, options = {}) # => HTTParty::Response`
+
+### Getting large objects
+The `get_object` method with out a block is suitable for small objects that easily fit in memory. For larger objects, specify a block to process chunked data as it comes in.
+
+```ruby
+File.open("/tmp/output", "wb") do |file_io|
+  swift_client.get_object("/large/object", "container") do |chunk|
+    file_io.write(chunk)
+  end
+end
+```
+
+## Re-Using/Sharing/Caching Auth Tokens
+
+Certain OpenStack/Swift providers have limits in place regarding token
+generation. To re-use auth tokens by caching them via memcached, install dalli
+
+`gem install dalli`
+
+and provide an instance of Dalli::Client to SwiftClient:
+
+```ruby
+swift_client = SwiftClient.new(
+  :auth_url => "https://example.com/auth/v1.0",
+  ...
+  :cache_store => Dalli::Client.new
+)
+```
+
+The cache key used to store the auth token will include all neccessary details
+to ensure the auth token won't be used for a different swift account erroneously.
+
+The cache implementation of SwiftClient is not restricted to memcached. To use
+a different one, simply implement a driver for your favorite cache store. See
+[null_cache.rb](https://github.com/mrkamel/swift_client/blob/master/lib/swift_client/null_cache.rb)
+for more info.
+
+## bulk_delete
+
+Takes an array containing container_name/object_name entries.
+Automatically slices and sends 1_000 items per request.
+
+## Non-chunked uploads
+
+By default files are uploaded in chunks and using a `Transfer-Encoding:
+chunked` header. You can override this by passing a `Transfer-Encoding:
+identity` header:
+
+```ruby
+put_object(object_name, data_or_io, container_name, "Transfer-Encoding" => "identity")
+```
 
 ## Contributing
 
@@ -154,3 +209,8 @@ SwiftClient offers the following requests:
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
+
+## Semantic Versioning
+
+Starting with version 0.2.0, SwiftClient uses Semantic Versioning:
+[SemVer](http://semver.org/)

data/lib/swift_client.rb

@@ -1,5 +1,6 @@
 
 require "swift_client/version"
+require "swift_client/null_cache"
 
 require "httparty"
 require "mime-types"
@@ -25,71 +26,72 @@ class SwiftClient
     end
   end
 
-  attr_accessor :options, :auth_token, :storage_url
+  attr_accessor :options, :auth_token, :storage_url, :cache_store
 
   def initialize(options = {})
     raise(OptionError, "Setting expires_in connection wide is deprecated") if options[:expires_in]
 
     self.options = options
+    self.cache_store = options[:cache_store] || SwiftClient::NullCache.new
 
     authenticate
   end
 
-  def head_account
-    request :head, "/"
+  def head_account(options = {})
+    request :head, "/", options
   end
 
-  def post_account(headers = {})
-    request :post, "/", :headers => headers
+  def post_account(headers = {}, options = {})
+    request :post, "/", options.merge(:headers => headers)
   end
 
-  def head_containers
-    request :head, "/"
+  def head_containers(options = {})
+    request :head, "/", options
   end
 
-  def get_containers(query = {})
-    request :get, "/", :query => query
+  def get_containers(query = {}, options = {})
+    request :get, "/", options.merge(:query => query)
   end
 
-  def paginate_containers(query = {}, &block)
-    paginate :get_containers, query, &block
+  def paginate_containers(query = {}, options = {}, &block)
+    paginate(:get_containers, query, options, &block)
   end
 
-  def get_container(container_name, query = {})
+  def get_container(container_name, query = {}, options = {})
     raise(EmptyNameError) if container_name.empty?
 
-    request :get, "/#{container_name}", :query => query
+    request :get, "/#{container_name}", options.merge(:query => query)
   end
 
-  def paginate_container(container_name, query = {}, &block)
-    paginate :get_container, container_name, query, &block
+  def paginate_container(container_name, query = {}, options = {}, &block)
+    paginate(:get_container, container_name, query, options, &block)
   end
 
-  def head_container(container_name)
+  def head_container(container_name, options = {})
     raise(EmptyNameError) if container_name.empty?
 
-    request :head, "/#{container_name}"
+    request :head, "/#{container_name}", options
   end
 
-  def put_container(container_name, headers = {})
+  def put_container(container_name, headers = {}, options = {})
     raise(EmptyNameError) if container_name.empty?
 
-    request :put, "/#{container_name}", :headers => headers
+    request :put, "/#{container_name}", options.merge(:headers => headers)
   end
 
-  def post_container(container_name, headers = {})
+  def post_container(container_name, headers = {}, options = {})
     raise(EmptyNameError) if container_name.empty?
 
-    request :post, "/#{container_name}", :headers => headers
+    request :post, "/#{container_name}", options.merge(:headers => headers)
   end
 
-  def delete_container(container_name)
+  def delete_container(container_name, options = {})
     raise(EmptyNameError) if container_name.empty?
 
-    request :delete, "/#{container_name}"
+    request :delete, "/#{container_name}", options
   end
 
-  def put_object(object_name, data_or_io, container_name, headers = {})
+  def put_object(object_name, data_or_io, container_name, headers = {}, options = {})
     raise(EmptyNameError) if object_name.empty? || container_name.empty?
 
     mime_type = MIME::Types.of(object_name).first
@@ -101,43 +103,52 @@ class SwiftClient
       extended_headers["Content-Type"] ||= "application/octet-stream"
     end
 
-    extended_headers["Transfer-Encoding"] = "chunked"
+    if extended_headers["Transfer-Encoding"] == "identity"
+      request :put, "/#{container_name}/#{object_name}", options.merge(:body => data_or_io.respond_to?(:read) ? data_or_io.read : data_or_io, :headers => extended_headers)
+    else
+      extended_headers["Transfer-Encoding"] = "chunked"
+      request :put, "/#{container_name}/#{object_name}", options.merge(:body_stream => data_or_io.respond_to?(:read) ? data_or_io : StringIO.new(data_or_io), :headers => extended_headers)
+    end
+  end
 
-    request :put, "/#{container_name}/#{object_name}", :body_stream => data_or_io.respond_to?(:read) ? data_or_io : StringIO.new(data_or_io), :headers => extended_headers
+  def post_object(object_name, container_name, headers = {}, options = {})
+    raise(EmptyNameError) if object_name.empty? || container_name.empty?
+
+    request :post, "/#{container_name}/#{object_name}", options.merge(:headers => headers)
   end
 
-  def post_object(object_name, container_name, headers = {})
+  def get_object(object_name, container_name, options = {}, &block)
     raise(EmptyNameError) if object_name.empty? || container_name.empty?
 
-    request :post, "/#{container_name}/#{object_name}", :headers => headers
+    request(:get, "/#{container_name}/#{object_name}", options.merge(block ? { :stream_body => true } : {}), &block)
   end
 
-  def get_object(object_name, container_name)
+  def head_object(object_name, container_name, options = {})
     raise(EmptyNameError) if object_name.empty? || container_name.empty?
 
-    request :get, "/#{container_name}/#{object_name}"
+    request :head, "/#{container_name}/#{object_name}", options
   end
 
-  def head_object(object_name, container_name)
+  def post_head(object_name, container_name, _headers = {}, options = {})
     raise(EmptyNameError) if object_name.empty? || container_name.empty?
 
-    request :head, "/#{container_name}/#{object_name}"
+    request :post, "/#{container_name}/#{object_name}", options.merge(headers: _headers)
   end
 
-  def delete_object(object_name, container_name)
+  def delete_object(object_name, container_name, options = {})
     raise(EmptyNameError) if object_name.empty? || container_name.empty?
 
-    request :delete, "/#{container_name}/#{object_name}"
+    request :delete, "/#{container_name}/#{object_name}", options
   end
 
-  def get_objects(container_name, query = {})
+  def get_objects(container_name, query = {}, options = {})
     raise(EmptyNameError) if container_name.empty?
 
-    request :get, "/#{container_name}", :query => query
+    request :get, "/#{container_name}", options.merge(:query => query)
   end
 
-  def paginate_objects(container_name, query = {}, &block)
-    paginate :get_objects, container_name, query, &block
+  def paginate_objects(container_name, query = {}, options = {}, &block)
+    paginate(:get_objects, container_name, query, options, &block)
   end
 
   def public_url(object_name, container_name)
@@ -158,27 +169,44 @@ class SwiftClient
     "#{storage_url}/#{container_name}/#{object_name}?temp_url_sig=#{signature}&temp_url_expires=#{expires}"
   end
 
+  def bulk_delete(items, options = {})
+    items.each_slice(1_000) do |slice|
+      request :delete, "/?bulk-delete", options.merge(:body => slice.join("\n"), :headers => { "Content-Type" => "text/plain" })
+    end
+
+    items
+  end
+
   private
 
+  def cache_key
+    auth_keys = [:auth_url, :username, :access_key, :user_id, :user_domain, :user_domain_id, :domain_name,
+      :domain_id, :token, :project_id, :project_name, :project_domain_name, :project_domain_id, :tenant_name]
+
+    auth_key = auth_keys.collect { |key| options[key] }.inspect
+
+    Digest::SHA1.hexdigest(auth_key)
+  end
+
   def find_header_key(headers, key)
     headers.keys.detect { |k| k.downcase == key.downcase }
   end
 
-  def request(method, path, opts = {})
+  def request(method, path, opts = {}, &block)
     headers = (opts[:headers] || {}).dup
     headers["X-Auth-Token"] = auth_token
     headers["Accept"] = "application/json"
 
     stream_pos = opts[:body_stream].pos if opts[:body_stream]
 
-    response = HTTParty.send(method, "#{storage_url}#{path}", opts.merge(:headers => headers))
+    response = HTTParty.send(method, "#{storage_url}#{path}", opts.merge(:headers => headers), &block)
 
     if response.code == 401
       authenticate
 
       opts[:body_stream].pos = stream_pos if opts[:body_stream]
 
-      return request(method, path, opts)
+      return request(method, path, opts, &block)
     end
 
     raise(ResponseError.new(response.code, response.message)) unless response.success?
@@ -187,12 +215,38 @@ class SwiftClient
   end
 
   def authenticate
+    return if authenticate_from_cache
+
     return authenticate_v3 if options[:auth_url] =~ /v3/
     return authenticate_v2 if options[:auth_url] =~ /v2/
 
     authenticate_v1
   end
 
+  def authenticate_from_cache
+    cached_auth_token = cache_store.get("swift_client:auth_token:#{cache_key}")
+    cached_storage_url = cache_store.get("swift_client:storage_url:#{cache_key}")
+
+    return false if cached_auth_token.nil? || cached_storage_url.nil?
+
+    if cached_auth_token != auth_token || cached_storage_url != storage_url
+      self.auth_token = cached_auth_token
+      self.storage_url = cached_storage_url
+
+      return true
+    end
+
+    false
+  end
+
+  def set_authentication_details(auth_token, storage_url)
+    cache_store.set("swift_client:auth_token:#{cache_key}", auth_token)
+    cache_store.set("swift_client:storage_url:#{cache_key}", storage_url)
+
+    self.auth_token = auth_token
+    self.storage_url = storage_url
+  end
+
   def authenticate_v1
     [:auth_url, :username, :api_key].each do |key|
       raise(AuthenticationError, "#{key} missing") unless options[key]
@@ -202,8 +256,7 @@ class SwiftClient
 
     raise(AuthenticationError, "#{response.code}: #{response.message}") unless response.success?
 
-    self.auth_token = response.headers["X-Auth-Token"]
-    self.storage_url = options[:storage_url] || response.headers["X-Storage-Url"]
+    set_authentication_details response.headers["X-Auth-Token"], options[:storage_url] || response.headers["X-Storage-Url"]
   end
 
   def authenticate_v2
@@ -231,8 +284,7 @@ class SwiftClient
 
     raise(AuthenticationError, "#{response.code}: #{response.message}") unless response.success?
 
-    self.auth_token = response.parsed_response["access"]["token"]["id"]
-    self.storage_url = options[:storage_url]
+    set_authentication_details response.parsed_response["access"]["token"]["id"], options[:storage_url]
   end
 
   def authenticate_v3
@@ -277,10 +329,11 @@ class SwiftClient
 
     raise(AuthenticationError, "#{response.code}: #{response.message}") unless response.success?
 
-    self.auth_token = response.headers["X-Subject-Token"]
-    self.storage_url = options[:storage_url] || storage_url_from_v3_response(response)
+    storage_url = options[:storage_url] || storage_url_from_v3_response(response)
 
     raise(AuthenticationError, "storage_url missing") unless storage_url
+
+    set_authentication_details response.headers["X-Subject-Token"], storage_url
   end
 
   def storage_url_from_v3_response(response)
@@ -289,7 +342,8 @@ class SwiftClient
 
     return unless swift_services.size == 1
 
-    swift_endpoints = swift_service["endpoints"].select { |endpoint| endpoint["interface"] == "public" }
+    interface = options[:interface] || "public"
+    swift_endpoints = swift_service["endpoints"].select { |endpoint| endpoint["interface"] == interface }
     swift_endpoint = swift_endpoints.first
 
     return unless swift_endpoints.size == 1
@@ -297,13 +351,13 @@ class SwiftClient
     swift_endpoint["url"]
   end
 
-  def paginate(method, *args, query)
-    return enum_for(:paginate, method, *args, query) unless block_given?
+  def paginate(method, *args, query, options)
+    return enum_for(:paginate, method, *args, query, options) unless block_given?
 
     marker = nil
 
     loop do
-      response = send(method, *args, marker ? query.merge(:marker => marker) : query)
+      response = send(method, *args, marker ? query.merge(:marker => marker) : query, options)
 
       return if response.parsed_response.empty?
 
@@ -313,4 +367,3 @@ class SwiftClient
     end
   end
 end
-

data/lib/swift_client/null_cache.rb

@@ -0,0 +1,11 @@
+
+class SwiftClient::NullCache
+  def get(key)
+    nil
+  end
+
+  def set(key, value)
+    true
+  end
+end
+

data/lib/swift_client/version.rb

@@ -1,5 +1,4 @@
 
 class SwiftClient
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end
-

data/test/swift_client_test.rb

@@ -1,6 +1,20 @@
 
 require File.expand_path("../test_helper", __FILE__)
 
+class MemoryCache
+  def initialize
+    @cache = {}
+  end
+
+  def set(key, value)
+    @cache[key] = value
+  end
+
+  def get(key)
+    @cache[key]
+  end
+end
+
 class SwiftClientTest < MiniTest::Test
   def setup
     stub_request(:get, "https://example.com/auth/v1.0").with(:headers => { "X-Auth-Key" => "secret", "X-Auth-User" => "account:username" }).to_return(:status => 200, :body => "", :headers => { "X-Auth-Token" => "Token", "X-Storage-Url" => "https://example.com/v1/AUTH_account" })
@@ -11,6 +25,22 @@ class SwiftClientTest < MiniTest::Test
     assert_equal "https://example.com/v1/AUTH_account", @swift_client.storage_url
   end
 
+  def test_authenticate_from_cache
+    cache = MemoryCache.new
+    cache.set("swift_client:auth_token:49f42f2927701ba93a5bf9750da8fedfa197fa82", "Cached token")
+    cache.set("swift_client:storage_url:49f42f2927701ba93a5bf9750da8fedfa197fa82", "https://cache.example.com/v1/AUTH_account")
+
+    @swift_client = SwiftClient.new(:auth_url => "https://example.com/auth/v1.0", :username => "account:username", :api_key => "secret", :temp_url_key => "Temp url key", :cache_store => cache)
+
+    assert_equal "Cached token", @swift_client.auth_token
+    assert_equal "https://cache.example.com/v1/AUTH_account", @swift_client.storage_url
+
+    @swift_client.send(:authenticate) # Re-authenticate
+
+    assert_equal "Token", @swift_client.auth_token
+    assert_equal "https://example.com/v1/AUTH_account", @swift_client.storage_url
+  end
+
   def test_v3_authentication_unscoped_with_password
     stub_request(:post, "https://auth.example.com/v3/auth/tokens").with(:body => JSON.dump("auth" => { "identity" => { "methods" => ["password"], "password" => { "user" => { "name" => "username", "password" => "secret", "domain" => { "name" => "example.com" }}}}})).to_return(:status => 200, :body => JSON.dump("token" => "..."), :headers => { "X-Subject-Token" => "Token", "Content-Type" => "application/json" })
 
@@ -47,6 +77,15 @@ class SwiftClientTest < MiniTest::Test
     assert_equal "https://example.com/v1/AUTH_account", @swift_client.storage_url
   end
 
+  def test_v3_authentication_storage_url_from_catalog_with_multiple_endpoints
+    stub_request(:post, "https://auth.example.com/v3/auth/tokens").with(:body => JSON.dump("auth" => { "identity" => { "methods" => ["password"], "password" => { "user" => { "name" => "username", "password" => "secret", "domain" => { "name" => "example.com" }}}}})).to_return(:status => 200, :body => JSON.dump("token" => { "catalog"=> [{ "type" => "object-store", "endpoints" => [{ "interface"=>"public", "url"=> "https://example.com/v1/AUTH_account" }, { "interface"=>"internal", "url"=> "https://example.com/v2/AUTH_account" }] }] }), :headers => { "X-Subject-Token" => "Token", "Content-Type" => "application/json" })
+
+    @swift_client = SwiftClient.new(:auth_url => "https://auth.example.com/v3", :username => "username", :user_domain => "example.com", :password => "secret", :interface => "internal")
+
+    assert_equal "Token", @swift_client.auth_token
+    assert_equal "https://example.com/v2/AUTH_account", @swift_client.storage_url
+  end
+
   def test_v3_authentication_without_storage_url_and_multiple_swifts
     stub_request(:post, "https://auth.example.com/v3/auth/tokens").with(:body => JSON.dump("auth" => { "identity" => { "methods" => ["password"], "password" => { "user" => { "name" => "username", "password" => "secret", "domain" => { "name" => "example.com" }}}}})).to_return(:status => 200, :body => JSON.dump("token" => { "catalog"=> [{ "type" => "object-store", "endpoints" => [{ "interface"=>"public", "url"=> "https://example.com/v1/AUTH_account" }] }, { "type" => "object-store", "endpoints" => [{ "interface"=>"public", "url"=> "https://example.com/v1/AUTH_account" }] }] }), :headers => { "X-Subject-Token" => "Token", "Content-Type" => "application/json" })
 
@@ -134,6 +173,18 @@ class SwiftClientTest < MiniTest::Test
     assert_equal containers, @swift_client.get_containers.parsed_response
   end
 
+  def test_bulk_delete
+    objects = [
+      "container1/object1",
+      "container1/object2",
+      "container2/object1"
+    ]
+
+    stub_request(:delete, "https://example.com/v1/AUTH_account/?bulk-delete").with(:body => objects.join("\n"), :headers => { "Content-Type" => "text/plain", "X-Auth-Token" => "Token" }).to_return(:status => 200,:body => "", :headers => { "Content-Type" => "application/json" })
+
+    assert @swift_client.bulk_delete(objects)
+  end
+
   def test_paginate_containers
     containers = [
       { "count" => 1, "bytes" => 1, "name" => "container-1" },
@@ -203,6 +254,12 @@ class SwiftClientTest < MiniTest::Test
     assert_equal 201, @swift_client.put_object("object", "data", "container", "X-Object-Meta-Test" => "Test").code
   end
 
+  def test_put_object_nonchunked
+    stub_request(:put, "https://example.com/v1/AUTH_account/container/object").with(:body => "data", :headers => { "Transfer-Encoding" => "identity", "Content-Type" => "application/octet-stream", "Accept" => "application/json", "X-Auth-Token" => "Token", "X-Object-Meta-Test" => "Test" }).to_return(:status => 201, :body => "", :headers => {})
+
+    assert_equal 201, @swift_client.put_object("object", "data", "container", "X-Object-Meta-Test" => "Test", "Transfer-Encoding" => "identity").code
+  end
+
   def test_put_object_with_renewed_authorization
     stub_request(:put, "https://example.com/v1/AUTH_account/container/object").with(:body => "data", :headers => { "Transfer-Encoding" => "chunked", "Content-Type" => "application/octet-stream", "Accept" => "application/json", "X-Auth-Token" => "Token" }).to_return({ :status => 401, :body => "", :headers => {}}, { :status => 201, :body => "", :headers => {}})
 
@@ -227,16 +284,38 @@ class SwiftClientTest < MiniTest::Test
     assert_equal 201, @swift_client.put_object("object", StringIO.new("data"), "container", "X-Object-Meta-Test" => "Test").code
   end
 
+  def test_put_object_with_io_nonchunked
+    stub_request(:put, "https://example.com/v1/AUTH_account/container/object").with(:body => "data", :headers => { "Transfer-Encoding" => "identity", "Accept" => "application/json", "X-Auth-Token" => "Token", "X-Object-Meta-Test" => "Test" }).to_return(:status => 201, :body => "", :headers => {})
+
+    assert_equal 201, @swift_client.put_object("object", StringIO.new("data"), "container", "X-Object-Meta-Test" => "Test", "Transfer-Encoding" => "identity").code
+  end
+
   def test_post_object
     stub_request(:post, "https://example.com/v1/AUTH_account/container/object").with(:headers => { "Accept" => "application/json", "X-Auth-Token" => "Token", "X-Object-Meta-Test" => "Test" }).to_return(:status => 201, :body => "", :headers => {})
 
     assert_equal 201, @swift_client.post_object("object", "container", "X-Object-Meta-Test" => "Test").code
   end
 
+  def test_post_head
+    stub_request(:post, 'https://example.com/v1/AUTH_account/container/object').with(headers: { 'Accept' => 'application/json', 'X-Auth-Token' => 'Token', 'X-Delete-At' => '1553524860' }).to_return(status: 201, body: '', headers: {})
+
+    assert_equal 201, @swift_client.post_head('object', 'container', 'X-Delete-At' => '1553524860').code
+  end
+
   def test_get_object
     stub_request(:get, "https://example.com/v1/AUTH_account/container/object").with(:headers => { "Accept" => "application/json", "X-Auth-Token" => "Token" }).to_return(:status => 200, :body => "Body", :headers => {})
+    block_res = 0
+
+    large_body = "Body" * 16384
+    stub_request(:get, "https://example.com/v1/AUTH_account/container/large_object").with(:headers => { "Accept" => "application/json", "X-Auth-Token" => "Token" }).to_return(:status => 200, :body => large_body, :headers => {})
 
     assert_equal "Body", @swift_client.get_object("object", "container").body
+
+    @swift_client.get_object("large_object", "container") do |chunk|
+      block_res += chunk.length
+    end
+
+    assert_equal block_res, large_body.length
   end
 
   def test_head_object
@@ -298,4 +377,3 @@ class SwiftClientTest < MiniTest::Test
     assert @swift_client.temp_url("object", "container", :expires_in => 86400) =~ %r{https://example.com/v1/AUTH_account/container/object\?temp_url_sig=[a-f0-9]{40}&temp_url_expires=1086400}
   end
 end
-

data/test/test_helper.rb

@@ -4,4 +4,4 @@ require "minitest"
 require "minitest/autorun"
 require "webmock/minitest"
 require "minitest/unit"
-require "mocha/mini_test"
+require "mocha/minitest"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swift_client
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Benjamin Vetter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-14 00:00:00.000000000 Z
+date: 2020-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -122,6 +122,7 @@ files:
 - README.md
 - Rakefile
 - lib/swift_client.rb
+- lib/swift_client/null_cache.rb
 - lib/swift_client/version.rb
 - swift_client.gemspec
 - test/swift_client_test.rb
@@ -145,8 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Small but powerful client to interact with OpenStack Swift