RubyGems - dwolla_swagger - Versions diffs - 1.0.6 → 1.0.7 - Mend

dwolla_swagger 1.0.6 → 1.0.7

Files changed (1714) hide show

data/vendor/bundle/ruby/2.2.0/gems/typhoeus-0.8.0/spec/typhoeus/response/informations_spec.rb DELETED Viewed

@@ -1,272 +0,0 @@
-require 'spec_helper'
-describe Typhoeus::Response::Informations do
-  let(:options) { {} }
-  let(:response) { Typhoeus::Response.new(options) }
-  describe "#return_code" do
-    let(:options) { { :return_code => :ok } }
-    it "returns return_code from options" do
-      expect(response.return_code).to be(:ok)
-    end
-  end
-  describe "#debug_info" do
-    let(:options) { { :debug_info => Ethon::Easy::DebugInfo.new } }
-    it "returns debug_info from options" do
-      expect(response.debug_info).to be_a(Ethon::Easy::DebugInfo)
-    end
-  end
-  describe "#return_message" do
-    let(:options) { { :return_code => :couldnt_connect } }
-    it "returns a message" do
-      expect(response.return_message).to eq("Couldn't connect to server")
-    end
-    describe "with nil return_code" do
-      let(:options) { { :return_code => nil } }
-      it "returns nil" do
-        expect(response.return_message).to be_nil
-      end
-    end
-  end
-  describe "#response_body" do
-    context "when response_body" do
-      let(:options) { { :response_body => "body" } }
-      it "returns response_body from options" do
-        expect(response.response_body).to eq("body")
-      end
-    end
-    context "when body" do
-      let(:options) { { :body => "body" } }
-      it "returns body from options" do
-        expect(response.body).to eq("body")
-      end
-    end
-  end
-  describe "#response_headers" do
-    let(:options) { { :response_headers => "Length: 1" } }
-    context "when no mock" do
-      it "returns response_headers from options" do
-        expect(response.response_headers).to eq("Length: 1")
-      end
-    end
-    context "when mock" do
-      context "when no response_headers" do
-        context "when headers" do
-          let(:options) { { :mock => true, :headers => {"Length" => 1, "Content-Type" => "text/plain" } } }
-          it "constructs response_headers" do
-            expect(response.response_headers).to include("Length: 1")
-            expect(response.response_headers).to include("Content-Type: text/plain")
-            expect(response.response_headers).to include("\r\n")
-          end
-        end
-      end
-    end
-  end
-  describe "#response_code" do
-    context "when response_code" do
-      let(:options) { { :response_code => "200" } }
-      it "returns response_code from options" do
-        expect(response.response_code).to eq(200)
-      end
-    end
-    context "when code" do
-      let(:options) { { :code => "200" } }
-      it "returns code from options" do
-        expect(response.code).to eq(200)
-      end
-    end
-  end
-  describe "#httpauth_avail" do
-    let(:options) { { :httpauth_avail => "code" } }
-    it "returns httpauth_avail from options" do
-      expect(response.httpauth_avail).to eq("code")
-    end
-  end
-  describe "#total_time" do
-    let(:options) { { :total_time =>  1 } }
-    it "returns total_time from options" do
-      expect(response.total_time).to eq(1)
-    end
-  end
-  describe "#starttransfer_time" do
-    let(:options) { { :starttransfer_time =>  1 } }
-    it "returns starttransfer_time from options" do
-      expect(response.starttransfer_time).to eq(1)
-    end
-  end
-  describe "#appconnect_time" do
-    let(:options) { { :appconnect_time =>  1 } }
-    it "returns appconnect_time from options" do
-      expect(response.appconnect_time).to eq(1)
-    end
-  end
-  describe "#pretransfer_time" do
-    let(:options) { { :pretransfer_time =>  1 } }
-    it "returns pretransfer_time from options" do
-      expect(response.pretransfer_time).to eq(1)
-    end
-  end
-  describe "#connect_time" do
-    let(:options) { { :connect_time =>  1 } }
-    it "returns connect_time from options" do
-      expect(response.connect_time).to eq(1)
-    end
-  end
-  describe "#namelookup_time" do
-    let(:options) { { :namelookup_time =>  1 } }
-    it "returns namelookup_time from options" do
-      expect(response.namelookup_time).to eq(1)
-    end
-  end
-  describe "#redirect_time" do
-    let(:options) { { :redirect_time =>  1 } }
-    it "returns redirect_time from options" do
-      expect(response.redirect_time).to eq(1)
-    end
-  end
-  describe "#effective_url" do
-    let(:options) { { :effective_url => "http://www.example.com" } }
-    it "returns effective_url from options" do
-      expect(response.effective_url).to eq("http://www.example.com")
-    end
-  end
-  describe "#primary_ip" do
-    let(:options) { { :primary_ip => "127.0.0.1" } }
-    it "returns primary_ip from options" do
-      expect(response.primary_ip).to eq("127.0.0.1")
-    end
-  end
-  describe "#redirect_count" do
-    let(:options) { { :redirect_count => 2 } }
-    it "returns redirect_count from options" do
-      expect(response.redirect_count).to eq(2)
-    end
-  end
-  describe "#request_size" do
-    let(:options) { { :request_size => 2 } }
-    it "returns request_size from options" do
-      expect(response.request_size).to eq(2)
-    end
-  end
-  describe "#headers" do
-    context "when no response_headers" do
-      it "returns nil" do
-        expect(response.headers).to be_nil
-      end
-    end
-    context "when response_headers" do
-      let(:options) { {:response_headers => "Expire: -1\nServer: gws"} }
-      it "returns nonempty headers" do
-        expect(response.headers).to_not be_empty
-      end
-      it "has Expire" do
-        expect(response.headers['expire']).to eq('-1')
-      end
-      it "has Server" do
-        expect(response.headers['server']).to eq('gws')
-      end
-    end
-    context "when multiple headers" do
-      let(:options) { {:response_headers => "Server: A\r\n\r\nServer: B"} }
-      it "returns the last" do
-        expect(response.headers['server']).to eq("B")
-      end
-    end
-    context "when mock" do
-      context "when headers" do
-        let(:options) { {:mock => true, :headers => {"Length" => "1"}} }
-        it "returns Typhoeus::Response::Header" do
-          expect(response.headers).to be_a(Typhoeus::Response::Header)
-        end
-        it "returns headers" do
-          expect(response.headers).to include("Length" => "1")
-        end
-      end
-    end
-    context "when requesting" do
-      let(:response) { Typhoeus.get("localhost:3001") }
-      it "returns headers" do
-        expect(response.headers).to_not be_empty
-      end
-    end
-  end
-  describe "#redirections" do
-    context "when no response_headers" do
-      it "returns empty array" do
-        expect(response.redirections).to be_empty
-      end
-    end
-    context "when headers" do
-      let(:options) { {:response_headers => "Expire: -1\nServer: gws"} }
-      it "returns empty array" do
-        expect(response.redirections).to be_empty
-      end
-    end
-    context "when multiple headers" do
-      let(:options) { {:response_headers => "Server: A\r\n\r\nServer: B"} }
-      it "returns response from all but last headers" do
-        expect(response.redirections.size).to eq(1)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/typhoeus-0.8.0/spec/typhoeus/response/status_spec.rb DELETED Viewed

@@ -1,218 +0,0 @@
-require 'spec_helper'
-describe Typhoeus::Response::Status do
-  let(:response) { Typhoeus::Response.new(options) }
-  let(:options) { {} }
-  describe "timed_out?" do
-    context "when return code is operation_timedout" do
-      let(:options) { {:return_code => :operation_timedout} }
-      it "return true" do
-        expect(response).to be_timed_out
-      end
-    end
-    context "when return code is couldnt_connect" do
-      let(:options) { {:return_code => :couldnt_connect} }
-      it "return true" do
-        expect(response).to be_timed_out
-      end
-    end
-    context "when return code is not operation_timedout or couldnt_connect" do
-      let(:options) { {:return_code => 14} }
-      it "returns false" do
-        expect(response).to_not be_timed_out
-      end
-    end
-  end
-  describe "#status_message" do
-    context "when no header" do
-      it "returns nil" do
-        expect(response.status_message).to be_nil
-      end
-    end
-    context "when header" do
-      context "when no message" do
-        let(:options) { {:response_headers => "HTTP/1.1 200\r\n"} }
-        it "returns nil" do
-          expect(response.status_message).to be_nil
-        end
-      end
-      context "when messsage" do
-        let(:options) { {:response_headers => "HTTP/1.1 200 message\r\n"} }
-        it "returns message" do
-          expect(response.status_message).to eq("message")
-        end
-      end
-    end
-  end
-  describe "#http_version" do
-    context "when no header" do
-      it "returns nil" do
-        expect(response.http_version).to be_nil
-      end
-    end
-    context "when header" do
-      context "when no http version" do
-        let(:options) { {:response_headers => "HTTP OK"} }
-        it "returns nil" do
-          expect(response.http_version).to be_nil
-        end
-      end
-      context "when invalid http_version" do
-        let(:options) { {:response_headers => "HTTP foo/bar OK"} }
-        it "returns nil" do
-          expect(response.http_version).to be_nil
-        end
-      end
-      context "when valid http_version" do
-        let(:options) { {:response_headers => "HTTP/1.1 OK"} }
-        it "returns http_version" do
-          expect(response.http_version).to eq("1.1")
-        end
-      end
-    end
-  end
-  describe "#success?" do
-    context "when response code 200-299" do
-      let(:options) { {:return_code => return_code, :response_code => 201} }
-      context "when mock" do
-        before { response.mock = true }
-        context "when return_code :ok" do
-          let(:return_code) { :ok }
-          it "returns true" do
-            expect(response.success?).to be_truthy
-          end
-        end
-        context "when return_code nil" do
-          let(:return_code) { nil }
-          it "returns true" do
-            expect(response.success?).to be_truthy
-          end
-        end
-      end
-      context "when no mock" do
-        before { response.mock = nil }
-        context "when return_code :ok" do
-          let(:return_code) { :ok }
-          it "returns true" do
-            expect(response.success?).to be_truthy
-          end
-        end
-        context "when return_code nil" do
-          let(:return_code) { nil }
-          it "returns false" do
-            expect(response.success?).to be_falsey
-          end
-        end
-      end
-    end
-    context "when response code is not 200-299" do
-      let(:options) { {:return_code => :ok, :response_code => 500} }
-      it "returns false" do
-        expect(response.success?).to be_falsey
-      end
-    end
-  end
-  describe "#modified?" do
-    context "when response code 304" do
-      let(:options) { {:return_code => :ok, :response_code => 304} }
-      context "when mock" do
-        before { response.mock = true }
-        context "when return_code :ok" do
-          let(:return_code) { :ok }
-          it "returns false" do
-            expect(response.modified?).to be_falsey
-          end
-        end
-        context "when return_code nil" do
-          let(:return_code) { nil }
-          it "returns false" do
-            expect(response.modified?).to be_falsey
-          end
-        end
-      end
-      context "when no mock" do
-        before { response.mock = nil }
-        context "when return_code :ok" do
-          let(:return_code) { :ok }
-          it "returns false" do
-            expect(response.modified?).to be_falsey
-          end
-        end
-        context "when return_code nil" do
-          let(:return_code) { nil }
-          it "returns true" do
-            expect(response.modified?).to be_falsey
-          end
-        end
-      end
-    end
-    context "when response code is not 304" do
-      let(:options) { {:return_code => :ok, :response_code => 500} }
-      it "returns true" do
-        expect(response.modified?).to be_truthy
-      end
-    end
-  end
-  describe "#first_header_line" do
-    context "when multiple header" do
-      let(:options) { {:response_headers => "1\r\n\r\n2\r\nbla"} }
-      it "returns first line of last block" do
-        expect(response.method(:first_header_line).call).to eq("2")
-      end
-    end
-    context "when single header" do
-      let(:options) { {:response_headers => "1"} }
-      it "returns first line" do
-        expect(response.method(:first_header_line).call).to eq("1")
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/typhoeus-0.8.0/spec/typhoeus/response_spec.rb DELETED Viewed

@@ -1,100 +0,0 @@
-require 'spec_helper'
-describe Typhoeus::Response do
-  let(:response) { Typhoeus::Response.new(options) }
-  let(:options) { {} }
-  describe ".new" do
-    context "when options" do
-      context "when return_code" do
-        let(:options) { {:return_code => 2} }
-        it "stores" do
-          expect(response.options[:return_code]).to be(2)
-        end
-      end
-      context "when headers" do
-        let(:options) { {:headers => {'A' => 'B'}} }
-        it "stores unmodified" do
-          expect(response.options[:headers]).to be(options[:headers])
-        end
-        it "sets @headers to a Typhoeus::Response::Header" do
-          expect(response.instance_variable_get(:@headers)).to be_a(Typhoeus::Response::Header)
-        end
-        it "has key" do
-          expect(response.headers['A']).to eq('B')
-        end
-      end
-    end
-  end
-  describe "#mock" do
-    context "when @mock" do
-      before { response.mock = true }
-      it "returns @mock" do
-        expect(response.mock).to be_truthy
-      end
-    end
-    context "when options[:mock]" do
-      let(:options) { {:mock => true} }
-      it "returns options[:mock]" do
-        expect(response.mock).to be_truthy
-      end
-    end
-    context "when @mock and options[:mock]" do
-      let(:options) { {:mock => 1} }
-      before { response.mock = 2 }
-      it "returns @mock" do
-        expect(response.mock).to be(2)
-      end
-    end
-  end
-  describe "#handled_response" do
-    let(:handled_response) { Typhoeus::Response.new }
-    context "when @handled_response" do
-      before { response.handled_response = handled_response }
-      it "returns @handled_response" do
-        expect(response.handled_response).to be(handled_response)
-      end
-    end
-    context "when @handled_response is nil" do
-      before { response.handled_response = nil }
-      it "returns response" do
-        expect(response.handled_response).to be(response)
-      end
-    end
-  end
-  describe "#cached" do
-    context "when @cached" do
-      before { response.cached = true }
-      it "returns cached status" do
-        expect(response.cached?).to be_truthy
-      end
-    end
-    context "when @cached is nil" do
-      before { response.cached = nil }
-      it "returns false" do
-        expect(response.cached?).to be_falsey
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/typhoeus-0.8.0/spec/typhoeus_spec.rb DELETED Viewed

@@ -1,105 +0,0 @@
-require 'spec_helper'
-describe Typhoeus do
-  before(:each) do
-    Typhoeus.configure { |config| config.verbose = false; config.block_connection = false }
-  end
-  describe ".configure" do
-    it "yields config" do
-      Typhoeus.configure do |config|
-        expect(config).to be_a(Typhoeus::Config)
-      end
-    end
-    it "sets values config" do
-      Typhoeus::Config.verbose = true
-      expect(Typhoeus::Config.verbose).to be_truthy
-    end
-  end
-  describe ".stub" do
-    let(:base_url) { "www.example.com" }
-    shared_examples "lazy response construction" do
-      it "calls the block to construct a response when a request matches the stub" do
-        expected_response = Typhoeus::Response.new
-        Typhoeus.stub(base_url) do |request|
-          expected_response
-        end
-        response = Typhoeus.get(base_url)
-        expect(response).to be(expected_response)
-      end
-    end
-    context "when no similar expectation exists" do
-      include_examples "lazy response construction"
-      it "returns expectation" do
-        expect(Typhoeus.stub(base_url)).to be_a(Typhoeus::Expectation)
-      end
-      it "adds expectation" do
-        Typhoeus.stub(:get, "")
-        expect(Typhoeus::Expectation.all.size).to eq(1)
-      end
-    end
-    context "when similar expectation exists" do
-      include_examples "lazy response construction"
-      let(:expectation) { Typhoeus::Expectation.new(base_url) }
-      before { Typhoeus::Expectation.all << expectation }
-      it "returns expectation" do
-        expect(Typhoeus.stub(base_url)).to be_a(Typhoeus::Expectation)
-      end
-      it "doesn't add expectation" do
-        Typhoeus.stub(base_url)
-        expect(Typhoeus::Expectation.all.size).to eq(1)
-      end
-    end
-  end
-  describe ".before" do
-    it "adds callback" do
-      Typhoeus.before { true }
-      expect(Typhoeus.before.size).to eq(1)
-    end
-  end
-  describe ".with_connection" do
-    it "executes block with block connection is false" do
-      Typhoeus.with_connection { expect(Typhoeus::Config.block_connection).to be(false) }
-    end
-    it "sets block connection back to previous value" do
-      Typhoeus::Config.block_connection = true
-      Typhoeus.with_connection {}
-      expect(Typhoeus::Config.block_connection).to be(true)
-    end
-    it "returns result of block" do
-      expect(Typhoeus.with_connection { "123" }).to eq("123")
-    end
-  end
-  [: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} requests" do
-          expect(response.response_body).to include("\"REQUEST_METHOD\":\"#{name.to_s.upcase}\"")
-        end
-      end
-    end
-  end
-end