typhoeus 1.0.1 → 1.4.0

data/spec/typhoeus/adapters/faraday_spec.rb

@@ -1,292 +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) { {} }
 
-        it "uses" do
-          adapter.method(:perform_request).call(env)
+      context "when body" do
+        let(:env) { { :body => double(:read => "body") } }
+
+        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 "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 "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)
+          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
-
-  describe "#configure_socket" do
-    let(:env) { { :request => { :bind => { :host => "interface" } } } }
 
-    before { adapter.method(:configure_socket).call(request, env) }
+    context "when the connection failed" do
+      before do
+        stub = Typhoeus::Response.new \
+          :response_code => 0,
+          :return_code => 0,
+          :mock          => true
 
-    context "when host" do
-      it "sets interface" do
-        expect(request.options[:interface]).to eq("interface")
+        Typhoeus.stub(base_url + '/').and_return(stub)
       end
-    end
-  end
 
-  describe "#configure_timeout" do
-    before { adapter.method(:configure_timeout).call(request, env) }
+      context "when parallel" do
+        it "isn't successful" do
+          response = nil
+          conn.in_parallel { response = conn.get("/") }
+          expect(response.success?).to be_falsey
+        end
 
-    context "when timeout" do
-      let(:env) { { :request => { :timeout => 1 } } }
+        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
 
-      it "sets timeout_ms" do
-        expect(request.options[:timeout_ms]).to eq(1000)
+      context "when not parallel" do
+        it "raises an error" do
+          expect { conn.get("/") }.to raise_error(Faraday::ConnectionFailed, "No error")
+        end
       end
     end
 
-    context "when open_timeout" do
-      let(:env) { { :request => { :open_timeout => 1 } } }
+    describe "#configure_socket" do
+      let(:env) { { :request => { :bind => { :host => "interface" } } } }
+
+      before { adapter.method(:configure_socket).call(request, env) }
 
-      it "sets connecttimeout_ms" do
-        expect(request.options[:connecttimeout_ms]).to eq(1000)
+      context "when host" do
+        it "sets interface" do
+          expect(request.options[:interface]).to eq("interface")
+        end
       end
     end
-  end
 
-  describe "#configure_proxy" do
-    before { adapter.method(:configure_proxy).call(request, env) }
+    describe "#configure_timeout" do
+      before { adapter.method(:configure_timeout).call(request, env) }
 
-    context "when proxy" do
-      let(:env) { { :request => { :proxy => { :uri => double(:scheme => 'http', :host => "localhost", :port => "3001") } } } }
+      context "when timeout" do
+        let(:env) { { :request => { :timeout => 1 } } }
 
-      it "sets proxy" do
-        expect(request.options[:proxy]).to eq("http://localhost:3001")
+        it "sets timeout_ms" do
+          expect(request.options[:timeout_ms]).to eq(1000)
+        end
       end
 
-      context "when username and password" do
-        let(:env) do
-          { :request => { :proxy => {
-            :uri => double(:scheme => 'http', :host => :a, :port => :b),
-            :user => "a",
-            :password => "b"
-          } } }
-        end
+      context "when open_timeout" do
+        let(:env) { { :request => { :open_timeout => 1 } } }
 
-        it "sets proxyuserpwd" do
-          expect(request.options[:proxyuserpwd]).to eq("a:b")
+        it "sets connecttimeout_ms" do
+          expect(request.options[:connecttimeout_ms]).to eq(1000)
         end
       end
     end
-  end
 
-  describe "#configure_ssl" do
-    before { adapter.method(:configure_ssl).call(request, env) }
+    describe "#configure_proxy" do
+      before { adapter.method(:configure_proxy).call(request, env) }
 
-    context "when version" do
-      let(:env) { { :ssl => { :version => "a" } } }
+      context "when proxy" do
+        let(:env) { { :request => { :proxy => { :uri => double(:scheme => 'http', :host => "localhost", :port => "3001") } } } }
 
-      it "sets sslversion" do
-        expect(request.options[:sslversion]).to eq("a")
+        it "sets proxy" do
+          expect(request.options[:proxy]).to eq("http://localhost:3001")
+        end
+
+        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
 
-    context "when client_cert" do
-      let(:env) { { :ssl => { :client_cert => "a" } } }
+    describe "#configure_ssl" do
+      before { adapter.method(:configure_ssl).call(request, env) }
+
+      context "when version" do
+        let(:env) { { :ssl => { :version => "a" } } }
 
-      it "sets sslcert" do
-        expect(request.options[:sslcert]).to eq("a")
+        it "sets sslversion" do
+          expect(request.options[:sslversion]).to eq("a")
+        end
       end
-    end
 
-    context "when client_key"  do
-      let(:env) { { :ssl => { :client_key => "a" } } }
+      context "when client_cert" do
+        let(:env) { { :ssl => { :client_cert => "a" } } }
 
-      it "sets sslkey" do
-        expect(request.options[:sslkey]).to eq("a")
+        it "sets sslcert" do
+          expect(request.options[:sslcert]).to eq("a")
+        end
       end
-    end
 
-    context "when ca_file"  do
-      let(:env) { { :ssl => { :ca_file => "a" } } }
+      context "when client_key"  do
+        let(:env) { { :ssl => { :client_key => "a" } } }
 
-      it "sets cainfo" do
-        expect(request.options[:cainfo]).to eq("a")
+        it "sets sslkey" do
+          expect(request.options[:sslkey]).to eq("a")
+        end
       end
-    end
 
-    context "when ca_path" do
-      let(:env) { { :ssl => { :ca_path => "a" } } }
+      context "when ca_file"  do
+        let(:env) { { :ssl => { :ca_file => "a" } } }
 
-      it "sets capath" do
-        expect(request.options[:capath]).to eq("a")
+        it "sets cainfo" do
+          expect(request.options[:cainfo]).to eq("a")
+        end
       end
-    end
 
-    context "when client_cert_passwd" do
-      let(:env) { { :ssl => { :client_cert_passwd => "a" } } }
+      context "when ca_path" do
+        let(:env) { { :ssl => { :ca_path => "a" } } }
 
-      it "sets keypasswd to the value of client_cert_passwd" do
-        expect(request.options[:keypasswd]).to eq("a")
+        it "sets capath" do
+          expect(request.options[:capath]).to eq("a")
+        end
       end
-    end
 
-    context "when client_certificate_password" do
-      let(:env) { { :ssl => { :client_certificate_password => "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 no client_cert_passwd" do
-      let(:env) { { :ssl => { } } }
+      context "when client_certificate_password" do
+        let(:env) { { :ssl => { :client_certificate_password => "a" } } }
 
-      it "does not set keypasswd on options" do
-        expect(request.options).not_to have_key :keypasswd
+        it "sets keypasswd to the value of client_cert_passwd" do
+          expect(request.options[:keypasswd]).to eq("a")
+        end
       end
-    end
 
-    context "when verify is false" do
-      let(:env) { { :ssl => { :verify => false } } }
+      context "when no client_cert_passwd" do
+        let(:env) { { :ssl => { } } }
 
-      it "sets ssl_verifyhost to 0" do
-        expect(request.options[:ssl_verifyhost]).to eq(0)
+        it "does not set keypasswd on options" do
+          expect(request.options).not_to have_key :keypasswd
+        end
       end
 
-      it "sets ssl_verifypeer to false" do
-        expect(request.options[:ssl_verifypeer]).to be_falsey
-      end
-    end
+      context "when verify is false" do
+        let(:env) { { :ssl => { :verify => false } } }
 
-    context "when verify is true" do
-      let(:env) { { :ssl => { :verify => true } } }
+        it "sets ssl_verifyhost to 0" do
+          expect(request.options[:ssl_verifyhost]).to eq(0)
+        end
 
-      it "sets ssl_verifyhost to 2" do
-        expect(request.options[:ssl_verifyhost]).to eq(2)
+        it "sets ssl_verifypeer to false" do
+          expect(request.options[:ssl_verifypeer]).to be_falsey
+        end
       end
 
-      it "sets ssl_verifypeer to true" do
-        expect(request.options[:ssl_verifypeer]).to be_truthy
+      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_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

data/spec/typhoeus/config_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Typhoeus::Config do
   let(:config) { Typhoeus::Config }
 
-  [:block_connection, :memoize, :verbose, :cache, :user_agent].each do |name|
+  [:block_connection, :memoize, :verbose, :cache, :user_agent, :proxy].each do |name|
     it "responds to #{name}" do
       expect(config).to respond_to(name)
     end

data/spec/typhoeus/easy_factory_spec.rb

@@ -104,6 +104,12 @@ describe Typhoeus::EasyFactory do
   end
 
   describe "#set_callback" do
+    it "sets easy.on_progress callback when an on_progress callback is provided" do
+      request.on_progress { 1 }
+      expect(easy_factory.easy).to receive(:on_progress)
+      easy_factory.send(:set_callback)
+    end
+
     it "sets easy.on_complete callback" do
       expect(easy_factory.easy).to receive(:on_complete)
       easy_factory.send(:set_callback)