typhoeus 0.4.2 → 1.4.0

data/spec/typhoeus/hydra/runnable_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe Typhoeus::Hydra::Runnable do
+  let(:base_url) { "localhost:3001" }
+  let(:options) { {} }
+  let(:hydra) { Typhoeus::Hydra.new(options) }
+  let(:receive_counter) { double :mark => :twain }
+
+  describe "#run" do
+    let(:requests) { [] }
+
+    before do
+      requests.each { |r| hydra.queue r }
+    end
+
+    it "runs multi#dequeue_many" do
+      expect(hydra).to receive(:dequeue_many)
+      hydra.run
+    end
+
+    it "runs multi#perform" do
+      expect(hydra.multi).to receive(:perform)
+      hydra.run
+    end
+
+    context "when request queued" do
+      let(:first) { Typhoeus::Request.new("localhost:3001/first") }
+      let(:requests) { [first] }
+
+      it "sends" do
+        hydra.run
+        expect(first.response).to be
+      end
+    end
+
+    context "when three request queued" do
+      let(:first) { Typhoeus::Request.new("localhost:3001/first") }
+      let(:second) { Typhoeus::Request.new("localhost:3001/second") }
+      let(:third) { Typhoeus::Request.new("localhost:3001/third") }
+      let(:requests) { [first, second, third] }
+
+      it "sends first" do
+        hydra.run
+        expect(first.response).to be
+      end
+
+      it "sends second" do
+        hydra.run
+        expect(second.response).to be
+      end
+
+      it "sends third" do
+        hydra.run
+        expect(third.response).to be
+      end
+
+      it "sends first first" do
+        first.on_complete do
+          expect(second.response).to be_nil
+          expect(third.response).to be_nil
+        end
+      end
+
+      it "sends second second" do
+        first.on_complete do
+          expect(first.response).to be
+          expect(third.response).to be_nil
+        end
+      end
+
+      it "sends thirds last" do
+        first.on_complete do
+          expect(second.response).to be
+          expect(third.response).to be
+        end
+      end
+    end
+
+    context "when really queued request" do
+      let(:options) { {:max_concurrency => 1} }
+      let(:first) { Typhoeus::Request.new("localhost:3001/first") }
+      let(:second) { Typhoeus::Request.new("localhost:3001/second") }
+      let(:third) { Typhoeus::Request.new("localhost:3001/third") }
+      let(:requests) { [first, second, third] }
+
+      it "sends first" do
+        hydra.run
+        expect(first.response).to be
+      end
+
+      it "sends second" do
+        hydra.run
+        expect(second.response).to be
+      end
+
+      it "sends third" do
+        hydra.run
+        expect(third.response).to be
+      end
+    end
+
+    context "when request queued in callback" do
+      let(:first) do
+        Typhoeus::Request.new("localhost:3001/first").tap do |r|
+          r.on_complete{ hydra.queue(second) }
+        end
+      end
+      let(:second) { Typhoeus::Request.new("localhost:3001/second") }
+      let(:requests) { [first] }
+
+      before { Typhoeus.on_complete { |r| receive_counter.mark } }
+      after { Typhoeus.on_complete.clear; Typhoeus.before.clear }
+
+      context "when real request" do
+        context "when max_concurrency default" do
+          let(:options) { {} }
+
+          it "calls on_complete callback once for every response" do
+            expect(receive_counter).to receive(:mark).exactly(2).times
+            hydra.run
+          end
+        end
+      end
+
+      context "when no real request" do
+        context "when before hook returns and finishes response" do
+          before { Typhoeus.before{ |request|  request.finish(Typhoeus::Response.new) } }
+
+          it "simulates real multi run and adds and finishes both requests" do
+            expect(receive_counter).to receive(:mark).exactly(2).times
+            hydra.run
+          end
+        end
+      end
+    end
+  end
+end

data/spec/typhoeus/hydra/stubbable_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Typhoeus::Hydra::Stubbable do
+  let(:base_url) { "localhost:3001" }
+  let(:request) { Typhoeus::Request.new(base_url) }
+  let(:response) { Typhoeus::Response.new }
+  let(:hydra) { Typhoeus::Hydra.new }
+
+  before { Typhoeus.stub(base_url).and_return(response) }
+
+  describe "#add" do
+    it "checks expectations" do
+      hydra.add(request)
+    end
+
+    context "when expectation found" do
+      it "calls on_headers callbacks" do
+        canary = :not_called
+        request.on_headers do
+          canary = :called
+        end
+        hydra.add(request)
+        hydra.run
+        expect(canary).to eq(:called)
+      end
+
+      it "calls on_body callbacks" do
+        canary = :not_called
+        request.on_body do
+          canary = :called
+        end
+        hydra.add(request)
+        hydra.run
+        expect(canary).to eq(:called)
+      end
+
+      it "finishes response" do
+        expect(request).to receive(:finish)
+        hydra.add(request)
+      end
+
+      it "is a mock" do
+        hydra.add(request)
+        expect(request.response.mock).to be(true)
+      end
+    end
+  end
+end

data/spec/typhoeus/hydra_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Typhoeus::Hydra do
+  let(:base_url) { "localhost:3001" }
+  let(:options) { {} }
+  let(:hydra) { Typhoeus::Hydra.new(options) }
+
+  describe "#new" do
+    let(:options) { {:pipeling => true} }
+
+    it "passes options to multi" do
+      expect(Ethon::Multi).to receive(:new).with(options)
+      hydra
+    end
+  end
+
+  describe "#hydra" do
+    it "returns a hydra" do
+      expect(Typhoeus::Hydra.hydra).to be_a(Typhoeus::Hydra)
+    end
+  end
+end

data/spec/typhoeus/pool_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe Typhoeus::Pool do
+  let(:easy) { Ethon::Easy.new }
+  after { Typhoeus::Pool.clear }
+
+  describe "#easies" do
+    it "returns array" do
+      expect(Typhoeus::Pool.send(:easies)).to be_a(Array)
+    end
+  end
+
+  describe "#release" do
+    it "resets easy" do
+      expect(easy).to receive(:reset)
+      Typhoeus::Pool.release(easy)
+    end
+
+    it "flush cookies to disk" do
+      expect(easy).to receive(:cookielist=).with('flush')
+      expect(easy).to receive(:reset)
+      expect(easy).to receive(:cookielist=).with('all')
+      Typhoeus::Pool.release(easy)
+    end
+
+    it "writes cookies to disk" do
+      tempfile1 = Tempfile.new('cookies')
+      tempfile2 = Tempfile.new('cookies')
+
+      easy.cookiejar = tempfile1.path
+      easy.url = "localhost:3001/cookies-test"
+      easy.perform
+
+      Typhoeus::Pool.release(easy)
+
+      expect(File.zero?(tempfile1.path)).to be(false)
+      expect(File.read(tempfile1.path)).to match(/\s+foo\s+bar$/)
+      expect(File.read(tempfile1.path)).to match(/\s+bar\s+foo$/)
+
+      # do it again - and check if tempfile1 wasn't change
+      easy.cookiejar = tempfile2.path
+      easy.url = "localhost:3001/cookies-test2"
+      easy.perform
+
+      Typhoeus::Pool.release(easy)
+
+      # tempfile 1
+      expect(File.zero?(tempfile1.path)).to be(false)
+      expect(File.read(tempfile1.path)).to match(/\s+foo\s+bar$/)
+      expect(File.read(tempfile1.path)).to match(/\s+bar\s+foo$/)
+
+      # tempfile2
+      expect(File.zero?(tempfile2.path)).to be(false)
+      expect(File.read(tempfile2.path)).to match(/\s+foo2\s+bar$/)
+      expect(File.read(tempfile2.path)).to match(/\s+bar2\s+foo$/)
+    end
+
+    it "puts easy back into pool" do
+      Typhoeus::Pool.release(easy)
+      expect(Typhoeus::Pool.send(:easies)).to include(easy)
+    end
+
+    context "when threaded access" do
+      it "releases correct number of easies" do
+        (0..9).map do |n|
+          Thread.new do
+            Typhoeus::Pool.release(Ethon::Easy.new)
+          end
+        end.map(&:join)
+        expect(Typhoeus::Pool.send(:easies).size).to eq(10)
+      end
+    end
+  end
+
+  describe "#get" do
+    context "when easy in pool" do
+      before { Typhoeus::Pool.send(:easies) << easy }
+
+      it "takes" do
+        expect(Typhoeus::Pool.get).to eq(easy)
+      end
+    end
+
+    context "when no easy in pool" do
+      it "creates" do
+        expect(Typhoeus::Pool.get).to be_a(Ethon::Easy)
+      end
+
+      context "when threaded access" do
+        it "creates correct number of easies" do
+          queue = Queue.new
+          (0..9).map do |n|
+            Thread.new do
+              queue.enq(Typhoeus::Pool.get)
+            end
+          end.map(&:join)
+
+          array = Array.new(queue.size) { queue.pop }
+          expect(array.uniq.size).to eq(10)
+        end
+      end
+    end
+
+    context "when forked" do
+      before do
+        allow(Process).to receive(:pid).and_return(1)
+        Typhoeus::Pool.send(:easies) << easy
+        allow(Process).to receive(:pid).and_return(2)
+      end
+
+      after do
+        allow(Process).to receive(:pid).and_call_original
+        Typhoeus::Pool.instance_variable_set(:@pid, Process.pid)
+      end
+
+      it "creates" do
+        expect(Typhoeus::Pool.get).to_not eq(easy)
+      end
+    end
+  end
+
+  describe "#with" do
+    it "is re-entrant" do
+      array = []
+      Typhoeus::Pool.with_easy do |e1|
+        array << e1
+        Typhoeus::Pool.with_easy do |e2|
+          array << e2
+          Typhoeus::Pool.with_easy do |e3|
+            array << e3
+          end
+        end
+      end
+      expect(array.uniq.size).to eq(3)
+    end
+  end
+end

data/spec/typhoeus/request/actions_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Typhoeus::Request::Actions do
+  [:get, :post, :put, :delete, :head, :patch, :options].each do |name|
+    describe ".#{name}" do
+      let(:response) { Typhoeus::Request.method(name).call("http://localhost:3001") }
+
+      it "returns ok" do
+        expect(response.return_code).to eq(:ok)
+      end
+
+      unless name == :head
+        it "makes #{name.to_s.upcase} Request" do
+          expect(response.response_body).to include("\"REQUEST_METHOD\":\"#{name.to_s.upcase}\"")
+        end
+      end
+    end
+  end
+end

data/spec/typhoeus/request/before_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Typhoeus::Request::Before do
+  let(:request) { Typhoeus::Request.new("") }
+  let(:receive_counter) { double :mark => :twain }
+
+  describe "#queue" do
+    context "when before" do
+      context "when one" do
+        it "executes" do
+          Typhoeus.before { |r| receive_counter.mark }
+          expect(receive_counter).to receive(:mark)
+          request.run
+        end
+
+        context "when true" do
+          it "calls super" do
+            Typhoeus.before { true }
+            expect(Typhoeus::Expectation).to receive(:response_for)
+            request.run
+          end
+        end
+
+        context "when false" do
+          it "doesn't call super" do
+            Typhoeus.before { false }
+            expect(Typhoeus::Expectation).to receive(:response_for).never
+            request.run
+          end
+
+          it "returns response" do
+            Typhoeus.before { |r| r.response = 1; false }
+            expect(request.run).to be(1)
+          end
+        end
+
+        context "when a response" do
+          it "doesn't call super" do
+            Typhoeus.before { Typhoeus::Response.new }
+            expect(Typhoeus::Expectation).to receive(:response_for).never
+            request.run
+          end
+
+          it "returns response" do
+            Typhoeus.before { |r| r.response = Typhoeus::Response.new }
+            expect(request.run).to be_a(Typhoeus::Response)
+          end
+        end
+      end
+
+      context "when multi" do
+        context "when all true" do
+          before { 3.times { Typhoeus.before { |r| receive_counter.mark } } }
+
+          it "calls super" do
+            expect(Typhoeus::Expectation).to receive(:response_for)
+            request.run
+          end
+
+          it "executes all" do
+            expect(receive_counter).to receive(:mark).exactly(3)
+            request.run
+          end
+        end
+
+        context "when middle false" do
+          before do
+            Typhoeus.before { |r| receive_counter.mark }
+            Typhoeus.before { |r| receive_counter.mark; nil }
+            Typhoeus.before { |r| receive_counter.mark }
+          end
+
+          it "doesn't call super" do
+            expect(Typhoeus::Expectation).to receive(:response_for).never
+            request.run
+          end
+
+          it "executes only two" do
+            expect(receive_counter).to receive(:mark).exactly(2).times
+            request.run
+          end
+        end
+      end
+    end
+
+    context "when no before" do
+      it "calls super" do
+        expect(Typhoeus::Expectation).to receive(:response_for)
+        request.run
+      end
+    end
+  end
+end

data/spec/typhoeus/request/block_connection_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Typhoeus::Request::BlockConnection do
+  let(:base_url) { "localhost:3001" }
+  let(:request) { Typhoeus::Request.new(base_url, {:method => :get}) }
+
+  describe "run" do
+    context "when blocked" do
+      before { request.block_connection = true }
+
+      it "raises" do
+        expect{ request.run }.to raise_error(Typhoeus::Errors::NoStub)
+      end
+    end
+
+    context "when not blocked" do
+      before { request.block_connection = false }
+
+      it "doesn't raise" do
+        expect{ request.run }.to_not raise_error
+      end
+    end
+  end
+
+  describe "#blocked?" do
+    context "when local block_connection" do
+      context "when true" do
+        before { request.block_connection = true }
+
+        it "returns true" do
+          expect(request.blocked?).to be_truthy
+        end
+      end
+
+      context "when false" do
+        before { request.block_connection = false }
+
+        it "returns false" do
+          expect(request.blocked?).to be_falsey
+        end
+      end
+    end
+
+    context "when global block_connection" do
+      context "when true" do
+        before { Typhoeus::Config.block_connection = true }
+        after { Typhoeus::Config.block_connection = false }
+
+        it "returns true" do
+          expect(request.blocked?).to be_truthy
+        end
+      end
+
+      context "when false" do
+        before { Typhoeus::Config.block_connection = false }
+
+        it "returns false" do
+          expect(request.blocked?).to be_falsey
+        end
+      end
+    end
+
+    context "when global and local block_connection" do
+      before do
+        Typhoeus::Config.block_connection = true
+        request.block_connection = false
+      end
+      after { Typhoeus::Config.block_connection = false }
+
+      it "takes local" do
+        expect(request.blocked?).to be_falsey
+      end
+    end
+  end
+end

data/spec/typhoeus/request/cacheable_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe Typhoeus::Request::Cacheable do
+  let(:cache) { MemoryCache.new }
+  let(:options) { {} }
+  let(:request) { Typhoeus::Request.new("http://localhost:3001", options) }
+  let(:response) { Typhoeus::Response.new }
+
+  before { Typhoeus::Config.cache = cache }
+  after { Typhoeus::Config.cache = false }
+
+  describe "#response=" do
+    context "when cache activated" do
+      context "when request new" do
+        it "caches response" do
+          request.response = response
+          expect(cache.memory[request]).to be
+        end
+
+        it "doesn't set cached on response" do
+          request.response = response
+          expect(request.response.cached?).to be_falsey
+        end
+      end
+
+      context "when request in memory" do
+        before { cache.memory[request] = response }
+
+        it "finishes request" do
+          expect(request).to receive(:finish).with(response)
+          request.run
+        end
+
+        it "sets cached to true for response" do
+          request.run
+          expect(request.response.cached?).to be_truthy
+        end
+      end
+    end
+  end
+
+  describe "#run" do
+    context "when cache activated" do
+      context "when request new" do
+        it "fetches response" do
+          expect(request.response).to_not be(response)
+        end
+      end
+
+      context "when request in memory" do
+        before { cache.memory[request] = response }
+
+        it "finishes request" do
+          expect(request).to receive(:finish).with(response)
+          request.run
+        end
+      end
+
+      context "when cache is specified on a request" do
+        before { Typhoeus::Config.cache = false }
+
+        context "when cache is false" do
+          let(:options) { { :cache => false } }
+
+          it "finishes request" do
+            expect(request.response).to_not be(response)
+            request.run
+          end
+        end
+
+        context "when cache is defined" do
+          let(:options) { { :cache => cache } }
+
+          before { cache.memory[request] = response }
+
+          it "finishes request" do
+            expect(request).to receive(:finish).with(response)
+            request.run
+          end
+        end
+      end
+    end
+  end
+
+  describe "#cache_ttl" do
+    context "when option[:cache_ttl]" do
+      let(:options) { {:cache_ttl => 1} }
+
+      it "returns" do
+        expect(request.cache_ttl).to be(1)
+      end
+    end
+  end
+end