typhoeus 1.4.1 → 1.5.0

data/spec/typhoeus/hydra/runnable_spec.rb

@@ -1,137 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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