typhoeus 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e844646bbdb137fea0fc50cf6c8d618ed1ef675
-  data.tar.gz: f2eef78a13606b8c957cae48afea61fe1118117b
+  metadata.gz: c35cbb02b3e9bdcd193c09c248738a23acc50878
+  data.tar.gz: 19be15bdcbf9dc8204353f852aa49c7f4d9748eb
 SHA512:
-  metadata.gz: 4e2cd0fdcdf92be70c916a75b95a8d3f6baf794e760c14f8dda7e0812ba965f686a9d720176e082e3cbe6b0cacd3013f79ea8f52deae7242f4728b44dc08b608
-  data.tar.gz: a76443341afde890cc9bfc6feb4e350effc9f8be7f36c5f61eb25d9afd0fcbeba182c675aa7a09bfb3ba514c6269543e4f0d2e5c81f0958c4986e0d9d06a9cd8
+  metadata.gz: d0e87a6220258b47dca9057d3be3c127a1d9b3aca5e5cb15de66e87e5838d8d72c9d442be79159fb1e607a83087c575aebc3f9c10ef1cfb81f0215dc20bff0f3
+  data.tar.gz: 7e79adf1409d6276be2ba4d8424e8c21181e8d8cd5c92998b2b4df41477827f3f8938ad9d133e3a53e65459ffbfebf3f0eefa664e052b82661167ab8bc6fcbd6

data/.travis.yml

@@ -13,12 +13,9 @@ rvm:
   - jruby-head
   - jruby-18mode
   - jruby-19mode
-  - rbx  # It's actually RBX 3
-  - rbx-2
 matrix: 
   fast_finish: true
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head
     - rvm: ree
-    - rvm: rbx

data/CHANGELOG.md

@@ -2,7 +2,11 @@
 
 ## Master
 
-[Full Changelog](http://github.com/typhoeus/typhoeus/compare/v1.1.0...master)
+[Full Changelog](http://github.com/typhoeus/typhoeus/compare/v1.1.1...master)
+
+## 1.1.1
+
+[Full Changelog](http://github.com/typhoeus/typhoeus/compare/v1.1.0...v1.1.1)
 
 ## 1.1.0
 

data/Gemfile

@@ -3,7 +3,7 @@ gemspec
 
 if Gem.ruby_version < Gem::Version.new("2.0.0")
   gem "rake", "< 11"
-  gem "json", "< 2"  
+  gem "json", "< 2"
 else
   gem "json"
   gem "rake"
@@ -13,7 +13,13 @@ group :development, :test do
   gem "rspec", "~> 3.0"
 
   gem "sinatra", "~> 1.3"
-  gem "faraday", ">= 0.9"
+
+  if Gem.ruby_version >= Gem::Version.new("1.9.0")
+    gem "faraday", ">= 0.9"
+    gem "dalli", "~> 2.0"
+  end
+
+  gem "redis", "~> 3.0"
 
   if RUBY_PLATFORM == "java"
     gem "spoon"

data/README.md

@@ -307,39 +307,26 @@ Typhoeus.get("www.example.com").cached?
 For use with [Dalli](https://github.com/mperham/dalli):
 
 ```ruby
-class Cache
-  def initialize
-    @client = Dalli::Client.new
-  end
-
-  def get(request)
-    @client.get(request.cache_key)
-  end
-
-  def set(request, response)
-    @client.set(request.cache_key, response)
-  end
-end
-
-Typhoeus::Config.cache = Cache.new
+dalli = Dalli::Client.new(...)
+Typhoeus::Config.cache = Typhoeus::Cache::Dalli.new(dalli)
 ```
 
 For use with Rails:
 
 ```ruby
-class Cache
-  def get(request)
-    Rails.cache.read(request)
-  end
+Typhoeus::Config.cache = Typhoeus::Cache::Rails.new
+```
 
-  def set(request, response)
-    Rails.cache.write(request, response)
-  end
-end
+For use with [Redis](https://github.com/redis/redis-rb):
 
-Typhoeus::Config.cache = Cache.new
+```ruby
+redis = Redis.new(...)
+Typhoeus::Config.cache = Typhoeus::Cache::Redis.new(redis)
 ```
 
+All three of these adapters take an optional keyword argument `default_ttl`, which sets a default
+TTL on cached responses (in seconds), for requests which do not have a cache TTL set.
+
 ### Direct Stubbing
 
 Hydra allows you to stub out specific urls and patterns to avoid hitting
@@ -397,7 +384,7 @@ and [`connecttimeout`](http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLO
 `timeout` is the time limit for the entire request in seconds.
 `connecttimeout` is the time limit for just the connection phase, again in seconds.
 
-There are two additional more fine grained opptions `timeout_ms` and
+There are two additional more fine grained options `timeout_ms` and
 `connecttimeout_ms`. These options offer millisecond precision but are not always available (for instance on linux if `nosignal` is not set to true).
 
 When you pass a floating point `timeout` (or `connecttimeout`) Typhoeus will set `timeout_ms` for you if it has not been defined. The actual timeout values passed to curl will always be rounded up.

data/lib/typhoeus.rb

@@ -17,6 +17,21 @@ if defined?(Rack)
   require "rack/typhoeus"
 end
 
+# If the Redis gem is available, load the redis cache adapter
+if defined?(Redis)
+  require "typhoeus/redis_cache"
+end
+
+# If the Dalli gem is available, load the Dalli cache adapter
+if defined?(Dalli)
+  require "typhoeus/dalli_cache"
+end
+
+# If we are using Rails, load the Rails cache adapter
+if defined?(Rails)
+  require "typhoeus/rails_cache"
+end
+
 # If we are using Rails, then we will include the Typhoeus railtie.
 # if defined?(Rails)
 #   require "typhoeus/railtie"

data/lib/typhoeus/adapters/faraday.rb

@@ -12,6 +12,9 @@ module Faraday # :nodoc:
     #
     #   conn = Faraday.new(url: "www.example.com") do |faraday|
     #     faraday.adapter :typhoeus
+    #
+    #     # You can include Typhoeus options to be used for every request
+    #     # faraday.adapter :typhoeus, forbid_reuse: true, maxredirs: 1
     #   end
     #
     #   response = conn.get("/")
@@ -32,6 +35,17 @@ module Faraday # :nodoc:
       remove_method :configure_socket  if method_defined? :configure_socket
       remove_method :parallel?         if method_defined? :parallel?
 
+      # Initialize the Typhoeus adapter
+      #
+      # @param [ App ] app Farday app
+      # @option [ Hash ] adapter_options Typhoeus options
+      #
+      # @return [ void ]
+      def initialize(app, adapter_options = {})
+        super(app)
+        @adapter_options = adapter_options
+      end
+
       # Setup Hydra with provided options.
       #
       # @example Setup Hydra.
@@ -72,12 +86,7 @@ module Faraday # :nodoc:
       def request(env)
         read_body env
 
-        req = ::Typhoeus::Request.new(
-          env[:url].to_s,
-          :method  => env[:method],
-          :body    => env[:body],
-          :headers => env[:request_headers]
-        )
+        req = typhoeus_request(env)
 
         configure_ssl     req, env
         configure_proxy   req, env
@@ -108,6 +117,16 @@ module Faraday # :nodoc:
         req
       end
 
+      def typhoeus_request(env)
+        opts = {
+          :method => env[:method],
+          :body => env[:body],
+          :headers => env[:request_headers]
+        }.merge(@adapter_options)
+
+        ::Typhoeus::Request.new(env[:url].to_s, opts)
+      end
+
       def read_body(env)
         env[:body] = env[:body].read if env[:body].respond_to? :read
       end

data/lib/typhoeus/cache/dalli.rb

@@ -0,0 +1,26 @@
+module Typhoeus
+  module Cache
+    # This module provides a simple way to cache HTTP responses using Dalli.
+    class Dalli
+      # @example Set Dalli as the Typhoeus cache backend
+      #   Typhoeus::Config.cache = Typhoeus::Cache::Dalli.new
+      #
+      # @param [ Dalli::Client ] client
+      #   A connection to the cache server. Defaults to `Dalli::Client.new`
+      # @param [ Integer ] default_ttl
+      #   The default TTL of cached responses in seconds, for requests which do not set a cache_ttl.
+      def initialize(client = ::Dalli::Client.new, options = {})
+        @client = client
+        @default_ttl = options[:default_ttl]
+      end
+
+      def get(request)
+        @client.get(request.cache_key)
+      end
+
+      def set(request, response)
+        @client.set(request.cache_key, response, request.cache_ttl || @default_ttl)
+      end
+    end
+  end
+end

data/lib/typhoeus/cache/rails.rb

@@ -0,0 +1,26 @@
+module Typhoeus
+  module Cache
+    # This module provides a simple way to cache HTTP responses in using the Rails cache.
+    class Rails
+      # @example Use the Rails cache setup to cache Typhoeus responses.
+      #   Typhoeus::Config.cache = Typhoeus::Cache::Rails.new
+      #
+      # @param [ ActiveSupport::Cache::Store ] cache
+      #   A Rails cache backend. Defaults to Rails.cache.
+      # @param [ Integer ] default_ttl
+      #   The default TTL of cached responses in seconds, for requests which do not set a cache_ttl.
+      def initialize(cache = ::Rails.cache, options = {})
+        @cache = cache
+        @default_ttl = options[:default_ttl]
+      end
+
+      def get(request)
+        @cache.read(request)
+      end
+
+      def set(request, response)
+        @cache.write(request, response, :expires_in => request.cache_ttl || @default_ttl)
+      end
+    end
+  end
+end

data/lib/typhoeus/cache/redis.rb

@@ -0,0 +1,33 @@
+module Typhoeus
+  module Cache
+    # This module provides a simple way to cache HTTP responses in Redis.
+    class Redis
+      # @example Set Redis as the Typhoeus cache backend
+      #   Typhoeus::Config.cache = Typhoeus::Cache::Redis.new
+      #
+      # @param [ Redis ] redis
+      #   A connection to Redis. Defaults to `Redis.new`, which uses the
+      #   `REDIS_URL` environment variable to connect
+      # @param [ Integer ] default_ttl
+      #   The default TTL of cached responses in seconds, for requests which do not set a cache_ttl.
+      def initialize(redis = ::Redis.new, options = {})
+        @redis = redis
+        @default_ttl = options[:default_ttl]
+      end
+
+      def get(request)
+        serialized_response = @redis.get(request.cache_key)
+        return unless serialized_response
+        Marshal.load(serialized_response)
+      end
+
+      def set(request, response)
+        ttl = request.cache_ttl || @default_ttl
+        key = request.cache_key
+        serialized_response = Marshal.dump(response)
+        @redis.set(key, serialized_response)
+        @redis.expire(key, ttl) if ttl
+      end
+    end
+  end
+end

data/lib/typhoeus/version.rb

@@ -1,5 +1,5 @@
 module Typhoeus
 
   # The current Typhoeus version.
-  VERSION = '1.1.0'
+  VERSION = '1.1.1'
 end

data/spec/typhoeus/adapters/faraday_spec.rb

@@ -1,323 +1,338 @@
-require 'spec_helper'
-require 'typhoeus/adapters/faraday'
-
-describe Faraday::Adapter::Typhoeus do
-  let(:base_url) { "http://localhost:3001" }
-  let(:adapter) { described_class.new }
-  let(:request) { Typhoeus::Request.new(base_url) }
-  let(:conn) do
-    Faraday.new(:url => base_url) do |faraday|
-      faraday.adapter  :typhoeus
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("1.9.0")
+  require 'spec_helper'
+  require 'typhoeus/adapters/faraday'
+
+  describe Faraday::Adapter::Typhoeus do
+    let(:base_url) { "http://localhost:3001" }
+    let(:adapter) { described_class.new(nil) }
+    let(:request) { Typhoeus::Request.new(base_url) }
+    let(:conn) do
+      Faraday.new(:url => base_url) do |faraday|
+        faraday.adapter  :typhoeus
+      end
     end
-  end
-  let(:response) { conn.get("/") }
+    let(:response) { conn.get("/") }
 
-  context "when parallel" do
-    it "returns a faraday response" do
-      response = nil
-      conn.in_parallel { response = conn.get("/") }
-      expect(response).to be_a(Faraday::Response)
-    end
+    context "when parallel" do
+      it "returns a faraday response" do
+        response = nil
+        conn.in_parallel { response = conn.get("/") }
+        expect(response).to be_a(Faraday::Response)
+      end
 
-    it "succeeds" do
-      response = nil
-      conn.in_parallel { response = conn.get("/") }
-      expect(response.status).to be(200)
+      it "succeeds" do
+        response = nil
+        conn.in_parallel { response = conn.get("/") }
+        expect(response.status).to be(200)
+      end
     end
-  end
 
-  context "when not parallel" do
-    it "returns a faraday response" do
-      expect(response).to be_a(Faraday::Response)
-    end
+    context "when not parallel" do
+      it "returns a faraday response" do
+        expect(response).to be_a(Faraday::Response)
+      end
 
-    it "succeeds" do
-      expect(response.status).to be(200)
+      it "succeeds" do
+        expect(response.status).to be(200)
+      end
     end
-  end
 
-  context "when a response is stubbed" do
-    before do
-      stub = Typhoeus::Response.new \
-        :code    => 200,
-        :headers => { "Foo" => "2", "Bar" => "3" },
-        :body    => "Hello",
-        :mock    => true
+    context "when a response is stubbed" do
+      before do
+        stub = Typhoeus::Response.new \
+          :code    => 200,
+          :headers => { "Foo" => "2", "Bar" => "3" },
+          :body    => "Hello",
+          :mock    => true
 
-      Typhoeus.stub(base_url + '/').and_return(stub)
-    end
+        Typhoeus.stub(base_url + '/').and_return(stub)
+      end
 
-    it 'stubs the status code' do
-      expect(response.status).to eq(200)
-    end
+      it 'stubs the status code' do
+        expect(response.status).to eq(200)
+      end
 
-    it 'stubs the response body' do
-      expect(response.body).to eq("Hello")
-    end
+      it 'stubs the response body' do
+        expect(response.body).to eq("Hello")
+      end
 
-    it 'stubs the headers' do
-      expect(response.headers).to eq("Foo" => "2", "Bar" => "3")
+      it 'stubs the headers' do
+        expect(response.headers).to eq("Foo" => "2", "Bar" => "3")
+      end
     end
-  end
 
-  describe "#perform_request" do
-    let(:env) { {} }
+    describe "#initialize" do
+      let(:request) { adapter.method(:typhoeus_request).call({}) }
 
-    context "when body" do
-      let(:env) { { :body => double(:read => "body") } }
+      context "when typhoeus request options specified" do
+        let(:adapter) { described_class.new(nil, { :forbid_reuse => true, :maxredirs => 1 }) }
 
-      it "reads body" do
-        expect(adapter.method(:read_body).call(env)).to eq("body")
+        it "should set option for request" do
+          expect(request.options[:forbid_reuse]).to be_truthy
+          expect(request.options[:maxredirs]).to eq(1)
+        end
       end
     end
 
-    context "parallel_manager" do
-      context "when given" do
-        let(:env) { { :parallel_manager => double(:queue => true), :ssl => {}, :request => {} } }
+    describe "#perform_request" do
+      let(:env) { {} }
+
+      context "when body" do
+        let(:env) { { :body => double(:read => "body") } }
 
-        it "uses" do
-          adapter.method(:perform_request).call(env)
+        it "reads body" do
+          expect(adapter.method(:read_body).call(env)).to eq("body")
         end
       end
 
-      context "when not given" do
-        let(:env) { { :method => :get, :ssl => {}, :request => {} } }
+      context "parallel_manager" do
+        context "when given" do
+          let(:env) { { :parallel_manager => double(:queue => true), :ssl => {}, :request => {} } }
+
+          it "uses" do
+            adapter.method(:perform_request).call(env)
+          end
+        end
+
+        context "when not given" do
+          let(:env) { { :method => :get, :ssl => {}, :request => {} } }
 
-        it "falls back to single" do
-          expect(Typhoeus::Request).to receive(:new).and_return(double(:options => {}, :on_complete => [], :run => true))
-          adapter.method(:perform_request).call(env)
+          it "falls back to single" do
+            expect(Typhoeus::Request).to receive(:new).and_return(double(:options => {}, :on_complete => [], :run => true))
+            adapter.method(:perform_request).call(env)
+          end
         end
       end
     end
-  end
 
-  describe "#request" do
-    let(:env) do
-      { :url => "url", :method => :get, :body => "body", :request_headers => {}, :ssl => {}, :request => {} }
-    end
+    describe "#request" do
+      let(:env) do
+        { :url => "url", :method => :get, :body => "body", :request_headers => {}, :ssl => {}, :request => {} }
+      end
 
-    let(:request) { adapter.method(:request).call(env) }
+      let(:request) { adapter.method(:request).call(env) }
 
-    it "returns request" do
-      expect(request).to be_a(Typhoeus::Request)
-    end
+      it "returns request" do
+        expect(request).to be_a(Typhoeus::Request)
+      end
 
-    it "sets url" do
-      expect(request.base_url).to eq("url")
-    end
+      it "sets url" do
+        expect(request.base_url).to eq("url")
+      end
 
-    it "sets http method" do
-      expect(request.original_options[:method]).to eq(:get)
-    end
+      it "sets http method" do
+        expect(request.original_options[:method]).to eq(:get)
+      end
 
-    it "sets body" do
-      expect(request.original_options[:body]).to eq("body")
-    end
+      it "sets body" do
+        expect(request.original_options[:body]).to eq("body")
+      end
 
-    it "sets headers" do
-      expect(request.original_options[:headers]).to eq({})
-    end
+      it "sets headers" do
+        expect(request.original_options[:headers]).to eq({})
+      end
 
-    it "sets on_complete callback" do
-      expect(request.on_complete.size).to eq(1)
+      it "sets on_complete callback" do
+        expect(request.on_complete.size).to eq(1)
+      end
     end
-  end
 
-  context "when the connection failed" do
-    before do
-      stub = Typhoeus::Response.new \
+    context "when the connection failed" do
+      before do
+        stub = Typhoeus::Response.new \
           :response_code => 0,
           :return_code => 0,
           :mock          => true
 
-      Typhoeus.stub(base_url + '/').and_return(stub)
-    end
-
-    context "when parallel" do
-      it "isn't successful" do
-        response = nil
-        conn.in_parallel { response = conn.get("/") }
-        expect(response.success?).to be_falsey
+        Typhoeus.stub(base_url + '/').and_return(stub)
       end
 
-      it "translates the response code into an error message" do
-        response = nil
-        conn.in_parallel { response = conn.get("/") }
-        expect(response.env[:typhoeus_return_message]).to eq("No error")
+      context "when parallel" do
+        it "isn't successful" do
+          response = nil
+          conn.in_parallel { response = conn.get("/") }
+          expect(response.success?).to be_falsey
+        end
+
+        it "translates the response code into an error message" do
+          response = nil
+          conn.in_parallel { response = conn.get("/") }
+          expect(response.env[:typhoeus_return_message]).to eq("No error")
+        end
       end
-    end
 
-    context "when not parallel" do
-      it "raises an error" do
-        expect { conn.get("/") }.to raise_error(Faraday::Error::ConnectionFailed, "No error")
+      context "when not parallel" do
+        it "raises an error" do
+          expect { conn.get("/") }.to raise_error(Faraday::Error::ConnectionFailed, "No error")
+        end
       end
     end
-  end
 
-  describe "#configure_socket" do
-    let(:env) { { :request => { :bind => { :host => "interface" } } } }
+    describe "#configure_socket" do
+      let(:env) { { :request => { :bind => { :host => "interface" } } } }
 
-    before { adapter.method(:configure_socket).call(request, env) }
+      before { adapter.method(:configure_socket).call(request, env) }
 
-    context "when host" do
-      it "sets interface" do
-        expect(request.options[:interface]).to eq("interface")
+      context "when host" do
+        it "sets interface" do
+          expect(request.options[:interface]).to eq("interface")
+        end
       end
     end
-  end
 
-  describe "#configure_timeout" do
-    before { adapter.method(:configure_timeout).call(request, env) }
+    describe "#configure_timeout" do
+      before { adapter.method(:configure_timeout).call(request, env) }
 
-    context "when timeout" do
-      let(:env) { { :request => { :timeout => 1 } } }
+      context "when timeout" do
+        let(:env) { { :request => { :timeout => 1 } } }
 
-      it "sets timeout_ms" do
-        expect(request.options[:timeout_ms]).to eq(1000)
+        it "sets timeout_ms" do
+          expect(request.options[:timeout_ms]).to eq(1000)
+        end
       end
-    end
 
-    context "when open_timeout" do
-      let(:env) { { :request => { :open_timeout => 1 } } }
+      context "when open_timeout" do
+        let(:env) { { :request => { :open_timeout => 1 } } }
 
-      it "sets connecttimeout_ms" do
-        expect(request.options[:connecttimeout_ms]).to eq(1000)
+        it "sets connecttimeout_ms" do
+          expect(request.options[:connecttimeout_ms]).to eq(1000)
+        end
       end
     end
-  end
-
-  describe "#configure_proxy" do
-    before { adapter.method(:configure_proxy).call(request, env) }
 
-    context "when proxy" do
-      let(:env) { { :request => { :proxy => { :uri => double(:scheme => 'http', :host => "localhost", :port => "3001") } } } }
+    describe "#configure_proxy" do
+      before { adapter.method(:configure_proxy).call(request, env) }
 
-      it "sets proxy" do
-        expect(request.options[:proxy]).to eq("http://localhost:3001")
-      end
+      context "when proxy" do
+        let(:env) { { :request => { :proxy => { :uri => double(:scheme => 'http', :host => "localhost", :port => "3001") } } } }
 
-      context "when username and password" do
-        let(:env) do
-          { :request => { :proxy => {
-            :uri => double(:scheme => 'http', :host => :a, :port => :b),
-            :user => "a",
-            :password => "b"
-          } } }
+        it "sets proxy" do
+          expect(request.options[:proxy]).to eq("http://localhost:3001")
         end
 
-        it "sets proxyuserpwd" do
-          expect(request.options[:proxyuserpwd]).to eq("a:b")
+        context "when username and password" do
+          let(:env) do
+            { :request => { :proxy => {
+              :uri => double(:scheme => 'http', :host => :a, :port => :b),
+              :user => "a",
+              :password => "b"
+            } } }
+          end
+
+          it "sets proxyuserpwd" do
+            expect(request.options[:proxyuserpwd]).to eq("a:b")
+          end
         end
       end
     end
-  end
 
-  describe "#configure_ssl" do
-    before { adapter.method(:configure_ssl).call(request, env) }
+    describe "#configure_ssl" do
+      before { adapter.method(:configure_ssl).call(request, env) }
 
-    context "when version" do
-      let(:env) { { :ssl => { :version => "a" } } }
+      context "when version" do
+        let(:env) { { :ssl => { :version => "a" } } }
 
-      it "sets sslversion" do
-        expect(request.options[:sslversion]).to eq("a")
+        it "sets sslversion" do
+          expect(request.options[:sslversion]).to eq("a")
+        end
       end
-    end
 
-    context "when client_cert" do
-      let(:env) { { :ssl => { :client_cert => "a" } } }
+      context "when client_cert" do
+        let(:env) { { :ssl => { :client_cert => "a" } } }
 
-      it "sets sslcert" do
-        expect(request.options[:sslcert]).to eq("a")
+        it "sets sslcert" do
+          expect(request.options[:sslcert]).to eq("a")
+        end
       end
-    end
 
-    context "when client_key"  do
-      let(:env) { { :ssl => { :client_key => "a" } } }
+      context "when client_key"  do
+        let(:env) { { :ssl => { :client_key => "a" } } }
 
-      it "sets sslkey" do
-        expect(request.options[:sslkey]).to eq("a")
+        it "sets sslkey" do
+          expect(request.options[:sslkey]).to eq("a")
+        end
       end
-    end
 
-    context "when ca_file"  do
-      let(:env) { { :ssl => { :ca_file => "a" } } }
+      context "when ca_file"  do
+        let(:env) { { :ssl => { :ca_file => "a" } } }
 
-      it "sets cainfo" do
-        expect(request.options[:cainfo]).to eq("a")
+        it "sets cainfo" do
+          expect(request.options[:cainfo]).to eq("a")
+        end
       end
-    end
 
-    context "when ca_path" do
-      let(:env) { { :ssl => { :ca_path => "a" } } }
+      context "when ca_path" do
+        let(:env) { { :ssl => { :ca_path => "a" } } }
 
-      it "sets capath" do
-        expect(request.options[:capath]).to eq("a")
+        it "sets capath" do
+          expect(request.options[:capath]).to eq("a")
+        end
       end
-    end
 
-    context "when client_cert_passwd" do
-      let(:env) { { :ssl => { :client_cert_passwd => "a" } } }
+      context "when client_cert_passwd" do
+        let(:env) { { :ssl => { :client_cert_passwd => "a" } } }
 
-      it "sets keypasswd to the value of client_cert_passwd" do
-        expect(request.options[:keypasswd]).to eq("a")
+        it "sets keypasswd to the value of client_cert_passwd" do
+          expect(request.options[:keypasswd]).to eq("a")
+        end
       end
-    end
 
-    context "when client_certificate_password" do
-      let(:env) { { :ssl => { :client_certificate_password => "a" } } }
+      context "when client_certificate_password" do
+        let(:env) { { :ssl => { :client_certificate_password => "a" } } }
 
-      it "sets keypasswd to the value of client_cert_passwd" do
-        expect(request.options[:keypasswd]).to eq("a")
+        it "sets keypasswd to the value of client_cert_passwd" do
+          expect(request.options[:keypasswd]).to eq("a")
+        end
       end
-    end
 
-    context "when no client_cert_passwd" do
-      let(:env) { { :ssl => { } } }
+      context "when no client_cert_passwd" do
+        let(:env) { { :ssl => { } } }
 
-      it "does not set keypasswd on options" do
-        expect(request.options).not_to have_key :keypasswd
+        it "does not set keypasswd on options" do
+          expect(request.options).not_to have_key :keypasswd
+        end
       end
-    end
 
-    context "when verify is false" do
-      let(:env) { { :ssl => { :verify => false } } }
+      context "when verify is false" do
+        let(:env) { { :ssl => { :verify => false } } }
 
-      it "sets ssl_verifyhost to 0" do
-        expect(request.options[:ssl_verifyhost]).to eq(0)
-      end
+        it "sets ssl_verifyhost to 0" do
+          expect(request.options[:ssl_verifyhost]).to eq(0)
+        end
 
-      it "sets ssl_verifypeer to false" do
-        expect(request.options[:ssl_verifypeer]).to be_falsey
+        it "sets ssl_verifypeer to false" do
+          expect(request.options[:ssl_verifypeer]).to be_falsey
+        end
       end
-    end
 
-    context "when verify is true" do
-      let(:env) { { :ssl => { :verify => true } } }
+      context "when verify is true" do
+        let(:env) { { :ssl => { :verify => true } } }
 
-      it "sets ssl_verifyhost to 2" do
-        expect(request.options[:ssl_verifyhost]).to eq(2)
-      end
+        it "sets ssl_verifyhost to 2" do
+          expect(request.options[:ssl_verifyhost]).to eq(2)
+        end
 
-      it "sets ssl_verifypeer to true" do
-        expect(request.options[:ssl_verifypeer]).to be_truthy
+        it "sets ssl_verifypeer to true" do
+          expect(request.options[:ssl_verifypeer]).to be_truthy
+        end
       end
     end
-  end
 
-  describe "#parallel?" do
-    context "when parallel_manager" do
-      let(:env) { { :parallel_manager => true } }
+    describe "#parallel?" do
+      context "when parallel_manager" do
+        let(:env) { { :parallel_manager => true } }
 
-      it "returns true" do
-        expect(adapter.method(:parallel?).call(env)).to be_truthy
+        it "returns true" do
+          expect(adapter.method(:parallel?).call(env)).to be_truthy
+        end
       end
-    end
 
-    context "when no parallel_manager" do
-      let(:env) { { :parallel_manager => nil } }
+      context "when no parallel_manager" do
+        let(:env) { { :parallel_manager => nil } }
 
-      it "returns false" do
-        expect(adapter.method(:parallel?).call(env)).to be_falsey
+        it "returns false" do
+          expect(adapter.method(:parallel?).call(env)).to be_falsey
+        end
       end
     end
   end

data/spec/typhoeus/cache/dalli_spec.rb

@@ -0,0 +1,41 @@
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("1.9.0")
+  require 'dalli'
+  require 'typhoeus/cache/dalli'
+  require 'spec_helper'
+
+  describe Typhoeus::Cache::Dalli do
+    let(:dalli) { instance_double(Dalli::Client) }
+    let(:cache) { Typhoeus::Cache::Dalli.new(dalli) }
+
+    let(:base_url) { "localhost:3001" }
+    let(:request) { Typhoeus::Request.new(base_url, {:method => :get}) }
+    let(:response) { Typhoeus::Response.new(:response_code => 0, :return_code => 0, :mock => true) }
+
+    describe "#set" do
+      it "sends the request to Dalli" do
+        expect(dalli).to receive(:set).with(request.cache_key, response, nil)
+
+        cache.set(request, response)
+      end
+    end
+
+    describe "#get" do
+      it "returns nil when the key is not in the cache" do
+        expect(dalli).to receive(:get).with(request.cache_key).and_return(nil)
+
+        expect(cache.get(request)).to be_nil
+      end
+
+      it "returns the cached response when the key is in cache" do
+        expect(dalli).to receive(:get).with(request.cache_key).and_return(response)
+
+        result = cache.get(request)
+        expect(result).to_not be_nil
+        expect(result.response_code).to eq(response.response_code)
+        expect(result.return_code).to eq(response.return_code)
+        expect(result.headers).to eq(response.headers)
+        expect(result.body).to eq(response.body)
+      end
+    end
+  end
+end

data/spec/typhoeus/cache/redis_spec.rb

@@ -0,0 +1,41 @@
+require 'redis'
+require 'typhoeus/cache/redis'
+require 'spec_helper'
+
+describe Typhoeus::Cache::Redis do
+  let(:redis) { instance_double(Redis) }
+  let(:cache) { Typhoeus::Cache::Redis.new(redis) }
+
+  let(:base_url) { "localhost:3001" }
+  let(:request) { Typhoeus::Request.new(base_url, {:method => :get}) }
+  let(:response) { Typhoeus::Response.new(:response_code => 0, :return_code => 0, :mock => true) }
+  let(:serialized_response) { Marshal.dump(response) }
+
+  describe "#set" do
+    it "sends the serialized request to Redis" do
+      expect(redis).to receive(:set).with(request.cache_key, serialized_response)
+      expect(redis).to_not receive(:expire).with(request.cache_key, request.cache_ttl)
+
+      cache.set(request, response)
+    end
+  end
+
+  describe "#get" do
+    it "returns nil when the key is not in Redis" do
+      expect(redis).to receive(:get).with(request.cache_key).and_return(nil)
+
+      expect(cache.get(request)).to be_nil
+    end
+
+    it "returns the cached response when the key is in Redis" do
+      expect(redis).to receive(:get).with(request.cache_key).and_return(serialized_response)
+
+      result = cache.get(request)
+      expect(result).to_not be_nil
+      expect(result.response_code).to eq(response.response_code)
+      expect(result.return_code).to eq(response.return_code)
+      expect(result.headers).to eq(response.headers)
+      expect(result.body).to eq(response.body)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typhoeus
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - David Balatero
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-21 00:00:00.000000000 Z
+date: 2016-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ethon
@@ -50,6 +50,9 @@ files:
 - lib/rack/typhoeus/middleware/params_decoder/helper.rb
 - lib/typhoeus.rb
 - lib/typhoeus/adapters/faraday.rb
+- lib/typhoeus/cache/dalli.rb
+- lib/typhoeus/cache/rails.rb
+- lib/typhoeus/cache/redis.rb
 - lib/typhoeus/config.rb
 - lib/typhoeus/easy_factory.rb
 - lib/typhoeus/errors.rb
@@ -94,6 +97,8 @@ files:
 - spec/support/memory_cache.rb
 - spec/support/server.rb
 - spec/typhoeus/adapters/faraday_spec.rb
+- spec/typhoeus/cache/dalli_spec.rb
+- spec/typhoeus/cache/redis_spec.rb
 - spec/typhoeus/config_spec.rb
 - spec/typhoeus/easy_factory_spec.rb
 - spec/typhoeus/errors/no_stub_spec.rb
@@ -157,6 +162,8 @@ test_files:
 - spec/support/memory_cache.rb
 - spec/support/server.rb
 - spec/typhoeus/adapters/faraday_spec.rb
+- spec/typhoeus/cache/dalli_spec.rb
+- spec/typhoeus/cache/redis_spec.rb
 - spec/typhoeus/config_spec.rb
 - spec/typhoeus/easy_factory_spec.rb
 - spec/typhoeus/errors/no_stub_spec.rb