typhoeus 1.4.1 → 1.5.0

data/spec/typhoeus/request/callbacks_spec.rb

@@ -1,91 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Request::Callbacks do
-  let(:request) { Typhoeus::Request.new("fubar") }
-
-  [:on_complete, :on_success, :on_failure, :on_progress].each do |callback|
-    describe "##{callback}" do
-      it "responds" do
-        expect(request).to respond_to(callback)
-      end
-
-      context "when no block given" do
-        it "returns @#{callback}" do
-          expect(request.method(callback).call).to eq([])
-        end
-      end
-
-      context "when block given" do
-        it "stores" do
-          request.method(callback).call { p 1 }
-          expect(request.instance_variable_get("@#{callback}").size).to eq(1)
-        end
-      end
-
-      context "when multiple blocks given" do
-        it "stores" do
-          request.method(callback).call { p 1 }
-          request.method(callback).call { p 2 }
-          expect(request.instance_variable_get("@#{callback}").size).to eq(2)
-        end
-      end
-    end
-  end
-
-  describe "#execute_callbacks" do
-    [:on_complete, :on_success, :on_failure, :on_progress].each do |callback|
-      context "when #{callback}" do
-        context "when local callback" do
-          before do
-            code = if callback == :on_failure
-              500
-            else
-              200
-            end
-            request.response = Typhoeus::Response.new(:mock => true, :response_code => code)
-            request.method(callback).call {|r| expect(r).to be_a(Typhoeus::Response) }
-          end
-
-          it "executes blocks and passes response" do
-            request.execute_callbacks
-          end
-
-          it "sets handled_response" do
-            request.method(callback).call { 1 }
-            request.execute_callbacks
-            expect(request.response.handled_response).to be(1)
-          end
-        end
-
-        context "when global callback" do
-          before do
-            request.response = Typhoeus::Response.new
-            Typhoeus.method(callback).call {|r| expect(r).to be_a(Typhoeus::Response) }
-          end
-
-          it "executes blocks and passes response" do
-            request.execute_callbacks
-          end
-        end
-
-        context "when global and local callbacks" do
-          before do
-            request.response = Typhoeus::Response.new
-            Typhoeus.method(callback).call {|r| r.instance_variable_set(:@fu, 1) }
-            request.method(callback).call {|r| expect(r.instance_variable_get(:@fu)).to eq(1) }
-          end
-
-          it "runs global first" do
-            request.execute_callbacks
-          end
-        end
-      end
-    end
-
-    context "when local on_complete and gobal on_success" do
-      it "runs all global callbacks first" do
-        skip
-      end
-    end
-  end
-end

data/spec/typhoeus/request/marshal_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Request::Marshal do
-  let(:base_url) { "localhost:3001" }
-  let(:request) { Typhoeus::Request.new(base_url) }
-
-  describe "#marshal_dump" do
-    %w(on_complete on_success on_failure on_progress).each do |name|
-      context "when #{name} handler" do
-        before { request.instance_variable_set("@#{name}", Proc.new{}) }
-
-        it "doesn't include @#{name}" do
-          expect(request.send(:marshal_dump).map(&:first)).to_not include("@#{name}")
-        end
-
-        it "doesn't raise when dumped" do
-          expect { Marshal.dump(request) }.to_not raise_error
-        end
-
-        context "when loading" do
-          let(:loaded) { Marshal.load(Marshal.dump(request)) }
-
-          it "includes base_url" do
-            expect(loaded.base_url).to eq(request.base_url)
-          end
-
-          it "doesn't include #{name}" do
-            expect(loaded.instance_variables).to_not include("@#{name}")
-          end
-        end
-      end
-    end
-
-    context 'when run through hydra' do
-      let(:options) { {} }
-      let(:hydra) { Typhoeus::Hydra.new(options) }
-
-      before(:each) do
-        hydra.queue(request)
-        hydra.run
-      end
-
-      it "doesn't include @hydra" do
-        expect(request.send(:marshal_dump).map(&:first)).to_not include("@hydra")
-      end
-
-      context 'when loading' do
-        let(:loaded) { Marshal.load(Marshal.dump(request)) }
-
-        it "includes base_url" do
-          expect(loaded.base_url).to eq(request.base_url)
-        end
-
-        it "doesn't include #{name}" do
-          expect(loaded.instance_variables).to_not include("@hydra")
-        end
-      end
-    end
-  end
-end

data/spec/typhoeus/request/memoizable_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Request::Memoizable do
-  let(:options) { {} }
-  let(:request) { Typhoeus::Request.new("fu", options) }
-  let(:response) { Typhoeus::Response.new }
-  let(:hydra) { Typhoeus::Hydra.new }
-
-  describe "#response=" do
-    context "when memoization activated" do
-      before { Typhoeus::Config.memoize = true }
-      after { Typhoeus::Config.memoize = false }
-
-      context "when GET request" do
-        let(:options) { {:method => :get} }
-        before { request.hydra = hydra }
-
-        it "stores response in memory" do
-          request.response = response
-          expect(hydra.memory[request]).to be
-        end
-      end
-
-      context "when no GET request" do
-        let(:options) { {:method => :post} }
-
-        it "doesn't store response in memory" do
-          request.response = response
-          expect(hydra.memory[request]).to be_nil
-        end
-      end
-    end
-  end
-end

data/spec/typhoeus/request/operations_spec.rb

@@ -1,101 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Request::Operations do
-  let(:base_url) { "localhost:3001" }
-  let(:options) { {} }
-  let(:request) { Typhoeus::Request.new(base_url, options) }
-
-  describe "#run" do
-    let(:easy) { Ethon::Easy.new }
-    before { expect(Typhoeus::Pool).to receive(:get).and_return(easy) }
-
-    it "grabs an easy" do
-      request.run
-    end
-
-    it "generates settings" do
-      expect(easy).to receive(:http_request)
-      request.run
-    end
-
-    it "performs" do
-      expect(easy).to receive(:perform)
-      request.run
-    end
-
-    it "sets response" do
-      request.run
-      expect(request.response).to be
-    end
-
-    it "releases easy" do
-      expect(Typhoeus::Pool).to receive(:release)
-      request.run
-    end
-
-    it "calls on_body" do
-      on_body_called = false
-      request.on_body { |body, response| on_body_called = true }
-      request.run
-      expect(on_body_called).to be_truthy
-      expect(request.response.body).to satisfy { |v| v.nil? || v == '' }
-    end
-
-    it "makes response headers available to on_body" do
-      headers = nil
-      request.on_body { |body, response| headers = response.headers }
-      request.run
-      expect(headers).to be
-      expect(headers).to eq(request.response.headers)
-    end
-
-    it "calls on_headers and on_body" do
-      headers = nil
-      request.on_headers { |response| headers = response.headers }
-      request.on_body { |body, response| expect(headers).not_to be_nil ; expect(response.headers).to eq(headers) }
-      request.on_complete { |response| expect(response).not_to be_nil ; expect(response.headers).to eq(headers) ; expect(response.body).to be_empty }
-      request.run
-    end
-
-    it "calls on_headers and on_complete" do
-      headers = nil
-      request.on_headers { |response| headers = response.headers }
-      request.on_complete { |response| expect(response).not_to be_nil ; expect(response.headers).to eq(headers) ; expect(response.body).not_to be_empty }
-      request.run
-    end
-
-    it "calls on_complete" do
-      callback = double(:call)
-      expect(callback).to receive(:call)
-      request.instance_variable_set(:@on_complete, [callback])
-      request.run
-    end
-
-    it "returns a response" do
-      expect(request.run).to be_a(Typhoeus::Response)
-    end
-  end
-
-  describe "#finish" do
-    let(:response) { Typhoeus::Response.new }
-
-    it "assigns response" do
-      request.finish(response)
-      expect(request.response).to be(response)
-    end
-
-    it "assigns request to response" do
-      request.finish(response)
-      expect(request.response.request).to be(request)
-    end
-
-    it "executes callbacks" do
-      expect(request).to receive(:execute_callbacks)
-      request.finish(response)
-    end
-
-    it "returns response" do
-      expect(request.finish(response)).to be(response)
-    end
-  end
-end

data/spec/typhoeus/request/responseable_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Request::Responseable do
-  let(:request) { Typhoeus::Request.new("base_url", {}) }
-  let(:response) { Typhoeus::Response.new }
-
-  describe "#response=" do
-    it "stores response" do
-      request.response = response
-      expect(request.response).to eq(response)
-    end
-  end
-end

data/spec/typhoeus/request/stubbable_spec.rb

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

data/spec/typhoeus/request_spec.rb

@@ -1,256 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Request do
-  let(:base_url) { "localhost:3001" }
-  let(:options) do
-    {
-      verbose: true,
-      headers: { "User-Agent" => "Fubar", "Expect" => "" },
-      maxredirs: 50
-    }
-  end
-  let(:request) { Typhoeus::Request.new(base_url, options) }
-
-  describe ".url" do
-    context "when no parameters" do
-      it "returns base_url" do
-        expect(request.url).to eq(request.base_url)
-      end
-    end
-
-    context "when parameters" do
-      let(:options) { {:params => {:a => 1}} }
-
-      it "returns full url" do
-        expect(request.url).to eq("#{request.base_url}?a=1")
-      end
-    end
-
-    it "pushes an easy back into the pool" do
-      easy = double.as_null_object
-      allow(Typhoeus::Pool).to receive(:get).and_return(easy)
-      expect(Typhoeus::Pool).to receive(:release).with(easy)
-      request.url
-    end
-  end
-
-  describe ".new" do
-    it "stores base_url" do
-      expect(request.base_url).to eq(base_url)
-    end
-
-    it "stores options" do
-      expect(request.options).to eq(options)
-    end
-
-    it "stores original options" do
-      expect(request.original_options).to eq(options)
-      expect(request.original_options).to_not be(request.options)
-    end
-
-    it "sets defaults" do
-      expect(request.options[:headers]['User-Agent']).to be
-    end
-  end
-
-  describe "set_defaults" do
-    context "when header with user agent" do
-      let(:options) { {:headers => {'User-Agent' => "Custom"} } }
-
-      it "doesn't modify user agent" do
-        expect(request.options[:headers]['User-Agent']).to eq("Custom")
-      end
-    end
-
-    context "when header without user agent" do
-      let(:options) { {:headers => {} } }
-
-      it "add user agent" do
-        agent = request.options[:headers]['User-Agent']
-        expect(agent).to eq(Typhoeus::USER_AGENT)
-      end
-    end
-
-    context "when Config.user_agent set" do
-      before { Typhoeus.configure { |config| config.user_agent = "Default" } }
-      after { Typhoeus.configure { |config| config.user_agent = nil } }
-
-      context "with headers" do
-        let(:options) { {:headers => { "User-Agent" => "Fubar" } } }
-
-        it "uses the request options' user agent" do
-          expect(request.options[:headers]["User-Agent"]).to eq("Fubar")
-        end
-      end
-
-      context "without headers" do
-        let(:options) { {:headers => {} } }
-
-        it "uses the global options' user agent" do
-          expect(request.options[:headers]["User-Agent"]).to eq("Default")
-        end
-      end
-    end
-
-    context "when Config.verbose set" do
-      before { Typhoeus.configure { |config| config.verbose = true} }
-      after { Typhoeus.configure { |config| config.verbose = false} }
-
-      it "respects" do
-        expect(request.options[:verbose]).to be_truthy
-      end
-    end
-
-    context "when Config.timeout set" do
-      before { Typhoeus.configure { |config| config.timeout = 10 } }
-      after { Typhoeus.configure { |config| config.timeout = nil } }
-
-      it "respects configuration" do
-        expect(request.options[:timeout]).to eq(10)
-      end
-    end
-
-    context "when Config.connecttimeout set" do
-      before { Typhoeus.configure { |config| config.connecttimeout = 10 } }
-      after { Typhoeus.configure { |config| config.connecttimeout = nil } }
-
-      it "respects configuration" do
-        expect(request.options[:connecttimeout]).to eq(10)
-      end
-    end
-
-    context "when maxredirs" do
-      context "when not set" do
-        it "defaults to 50" do
-          expect(request.options[:maxredirs]).to be(50)
-        end
-      end
-
-      context "when set" do
-        let(:options) { {:maxredirs => 1} }
-
-        it "respects" do
-          expect(request.options[:maxredirs]).to be(1)
-        end
-      end
-    end
-
-    context "when Config.proxy set" do
-      before { Typhoeus.configure { |config| config.proxy = "http://proxy.internal" } }
-      after { Typhoeus.configure { |config| config.proxy = nil } }
-
-      it "respects" do
-        expect(request.options[:proxy]).to eq("http://proxy.internal")
-      end
-
-      context "when option proxy set" do
-        let(:options) { {:proxy => nil} }
-
-        it "does not override" do
-          expect(request.options[:proxy]).to be_nil
-        end
-      end
-    end
-  end
-
-  describe "#eql?" do
-    context "when another class" do
-      let(:other) { "" }
-
-      it "returns false" do
-        expect(request).to_not eql other
-      end
-    end
-
-    context "when same class" do
-      let(:other) { Typhoeus::Request.new("base_url", options) }
-
-      context "when other base_url" do
-        it "returns false" do
-          expect(request).to_not eql other
-        end
-      end
-
-      context "when same base_url and other options" do
-        let(:other) { Typhoeus::Request.new(base_url, {}) }
-
-        it "returns false" do
-          expect(request).to_not eql other
-        end
-      end
-
-
-      context "when same base_url and options" do
-        context "when same order" do
-          let(:other) { Typhoeus::Request.new(base_url, options) }
-
-          it "returns true" do
-            expect(request).to eql other
-          end
-        end
-
-        context "when different order" do
-          let(:other_options) {
-            {:headers => { 'User-Agent' => "Fubar", 'Expect' => ""}, :verbose => true }
-          }
-          let(:other) { Typhoeus::Request.new(base_url, other_options)}
-
-          it "returns true" do
-            expect(request).to eql other
-          end
-        end
-      end
-    end
-  end
-
-  describe "#hash" do
-    context "when request.eql?(other)" do
-      context "when different order" do
-        let(:other_options) {
-          {:headers => { 'User-Agent' => "Fubar", 'Expect' => "" }, :verbose => true }
-        }
-        let(:other) { Typhoeus::Request.new(base_url, other_options)}
-
-        it "has same hashes" do
-          expect(request.hash).to eq(other.hash)
-        end
-      end
-
-      context "when same order" do
-        let(:other) { Typhoeus::Request.new(base_url, options) }
-
-        it "has same hashes" do
-          expect(request.hash).to eq(other.hash)
-        end
-      end
-
-      context "when hashes with different orders are contained in arrays" do
-        let(:request) { Typhoeus::Request.new(base_url, :params => [{:b => 2, :a => 1}]) }
-        let(:other) { Typhoeus::Request.new(base_url, :params => [{:a => 1, :b => 2}]) }
-        it "has different hashes" do
-          expect(request.hash).to eq(other.hash)
-        end
-      end
-    end
-
-    context "when not request.eql?(other)" do
-      let(:request) { Typhoeus::Request.new(base_url, :params => {:foo => 'bar'}) }
-      let(:other) { Typhoeus::Request.new(base_url, :params => {:foo => 'baz'}) }
-
-      it "has different hashes" do
-        expect(request.hash).to_not eq(other.hash)
-      end
-    end
-  end
-
-  describe "#encoded_body" do
-    let(:request) {
-      Typhoeus::Request.new("www.example.com",:body => {:a => 1})
-    }
-
-    it "returns encoded body" do
-      expect(request.encoded_body).to eq("a=1")
-    end
-  end
-
-end