Add bin and edit workflow

bin/gems/typhoeus-1.4.1/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

bin/gems/typhoeus-1.4.1/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

bin/gems/typhoeus-1.4.1/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

bin/gems/typhoeus-1.4.1/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

bin/gems/typhoeus-1.4.1/spec/typhoeus/request/callbacks_spec.rb

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

bin/gems/typhoeus-1.4.1/spec/typhoeus/request/marshal_spec.rb

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

bin/gems/typhoeus-1.4.1/spec/typhoeus/request/memoizable_spec.rb

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

bin/gems/typhoeus-1.4.1/spec/typhoeus/request/operations_spec.rb

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

bin/gems/typhoeus-1.4.1/spec/typhoeus/request/responseable_spec.rb

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

bin/gems/typhoeus-1.4.1/spec/typhoeus/request/stubbable_spec.rb

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