faraday_middleware 0.9.1 → 1.2.0

data/spec/chunked_spec.rb

@@ -1,78 +0,0 @@
-require 'helper'
-require 'faraday_middleware/response/chunked'
-
-describe FaradayMiddleware::Chunked, :type => :response do
-  context "no transfer-encoding" do
-    it "doesn't change nil body" do
-      expect(process(nil).body).to be_nil
-    end
-
-    it "doesn't change an empty body" do
-      expect(process('').body).to eq('')
-    end
-
-    it "doesn't change a normal body" do
-      expect(process('asdf').body).to eq('asdf')
-    end
-  end
-
-  context "transfer-encoding gzip" do
-    let(:headers) { {"transfer-encoding" => "gzip"}}
-
-    it "doesn't change nil body" do
-      expect(process(nil).body).to be_nil
-    end
-
-    it "doesn't change an empty body" do
-      expect(process('').body).to eq('')
-    end
-
-    it "doesn't change a normal body" do
-      expect(process('asdf').body).to eq('asdf')
-    end
-  end
-
-  context "transfer-encoding chunked" do
-    let(:headers) { {"transfer-encoding" => "chunked"}}
-
-    it "doesn't change nil body" do
-      expect(process(nil).body).to be_nil
-    end
-
-    it "doesn't change an empty body" do
-      expect(process('').body).to eq('')
-    end
-
-    it "parses a basic chunked body" do
-      expect(process("10\r\nasdfghjklasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
-    end
-
-    it "parses a chunked body with no ending chunk" do
-      expect(process("10\r\nasdfghjklasdfghj\r\n").body).to eq('asdfghjklasdfghj')
-    end
-
-    it "parses a chunked body with no trailing CRLF on the data chunk" do
-      expect(process("10\r\nasdfghjklasdfghj0\r\n").body).to eq('asdfghjklasdfghj')
-    end
-
-    it "parses a chunked body with an extension" do
-      expect(process("10;foo=bar\r\nasdfghjklasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
-    end
-
-    it "parses a chunked body with two extensions" do
-      expect(process("10;foo=bar;bar=baz\r\nasdfghjklasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
-    end
-
-    it "parses a chunked body with two chunks" do
-      expect(process("8\r\nasdfghjk\r\n8\r\nlasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
-    end
-  end
-
-  context "transfer-encoding chunked,chunked" do
-    let(:headers) { {"transfer-encoding" => "chunked,chunked"}}
-
-    it "parses a basic chunked body" do
-      expect(process("10\r\nasdfghjklasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
-    end
-  end
-end

data/spec/encode_json_spec.rb

@@ -1,95 +0,0 @@
-require 'helper'
-require 'faraday_middleware/request/encode_json'
-
-describe FaradayMiddleware::EncodeJson do
-  let(:middleware) { described_class.new(lambda{|env| env}) }
-
-  def process(body, content_type = nil)
-    env = {:body => body, :request_headers => Faraday::Utils::Headers.new}
-    env[:request_headers]['content-type'] = content_type if content_type
-    middleware.call(faraday_env(env))
-  end
-
-  def result_body() result[:body] end
-  def result_type() result[:request_headers]['content-type'] end
-
-  context "no body" do
-    let(:result) { process(nil) }
-
-    it "doesn't change body" do
-      expect(result_body).to be_nil
-    end
-
-    it "doesn't add content type" do
-      expect(result_type).to be_nil
-    end
-  end
-
-  context "empty body" do
-    let(:result) { process('') }
-
-    it "doesn't change body" do
-      expect(result_body).to be_empty
-    end
-
-    it "doesn't add content type" do
-      expect(result_type).to be_nil
-    end
-  end
-
-  context "string body" do
-    let(:result) { process('{"a":1}') }
-
-    it "doesn't change body" do
-      expect(result_body).to eq('{"a":1}')
-    end
-
-    it "adds content type" do
-      expect(result_type).to eq('application/json')
-    end
-  end
-
-  context "object body" do
-    let(:result) { process({:a => 1}) }
-
-    it "encodes body" do
-      expect(result_body).to eq('{"a":1}')
-    end
-
-    it "adds content type" do
-      expect(result_type).to eq('application/json')
-    end
-  end
-
-  context "empty object body" do
-    let(:result) { process({}) }
-
-    it "encodes body" do
-      expect(result_body).to eq('{}')
-    end
-  end
-
-  context "object body with json type" do
-    let(:result) { process({:a => 1}, 'application/json; charset=utf-8') }
-
-    it "encodes body" do
-      expect(result_body).to eq('{"a":1}')
-    end
-
-    it "doesn't change content type" do
-      expect(result_type).to eq('application/json; charset=utf-8')
-    end
-  end
-
-  context "object body with incompatible type" do
-    let(:result) { process({:a => 1}, 'application/xml; charset=utf-8') }
-
-    it "doesn't change body" do
-      expect(result_body).to eq({:a => 1})
-    end
-
-    it "doesn't change content type" do
-      expect(result_type).to eq('application/xml; charset=utf-8')
-    end
-  end
-end

data/spec/follow_redirects_spec.rb

@@ -1,221 +0,0 @@
-require 'helper'
-require 'faraday_middleware/response/follow_redirects'
-require 'faraday'
-
-# expose a method in Test adapter that should have been public
-Faraday::Adapter::Test::Stubs.class_eval { public :new_stub }
-
-describe FaradayMiddleware::FollowRedirects do
-  let(:middleware_options) { Hash.new }
-
-  shared_examples_for "a successful redirection" do |status_code|
-    it "follows the redirection for a GET request" do
-      expect(connection do |stub|
-        stub.get('/permanent') { [status_code, {'Location' => '/found'}, ''] }
-        stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
-      end.get('/permanent').body).to eq 'fin'
-    end
-
-    it "follows the redirection for a HEAD request" do
-      expect(connection do |stub|
-               stub.head('/permanent') { [status_code, {'Location' => '/found'}, ''] }
-               stub.head('/found') { [200, {'Content-Type' => 'text/plain'}, ''] }
-             end.head('/permanent').status).to eq 200
-    end
-
-    it "follows the redirection for a OPTIONS request" do
-      expect(connection do |stub|
-               stub.new_stub(:options, '/permanent') { [status_code, {'Location' => '/found'}, ''] }
-               stub.new_stub(:options, '/found') { [200, {'Content-Type' => 'text/plain'}, ''] }
-             end.run_request(:options, '/permanent', nil, nil).status).to eq 200
-    end
-  end
-
-  shared_examples_for "a forced GET redirection" do |status_code|
-    [:put, :post, :delete, :patch].each do |method|
-      it "a #{method.to_s.upcase} request is converted to a GET" do
-        expect(connection do |stub|
-          stub.new_stub(method, '/redirect') {
-            [status_code, {'Location' => '/found'}, 'elsewhere']
-          }
-          stub.get('/found') { |env|
-            body = env[:body] and body.empty? && (body = nil)
-            [200, {'Content-Type' => 'text/plain'}, body.inspect]
-          }
-        end.run_request(method, '/redirect', 'request data', nil).body).to eq('nil')
-      end
-    end
-  end
-
-  shared_examples_for "a replayed redirection" do |status_code|
-    it "redirects with the original request headers" do
-      conn = connection do |stub|
-        stub.get('/redirect') {
-          [status_code, {'Location' => '/found'}, '']
-        }
-        stub.get('/found') { |env|
-          [200, {'Content-Type' => 'text/plain'}, env[:request_headers]['X-Test-Value']]
-        }
-      end
-
-      response = conn.get('/redirect') { |req|
-        req.headers['X-Test-Value'] = 'success'
-      }
-
-      expect(response.body).to eq('success')
-    end
-
-    [:put, :post, :delete, :patch].each do |method|
-      it "replays a #{method.to_s.upcase} request" do
-        expect(connection do |stub|
-          stub.new_stub(method, '/redirect') { [status_code, {'Location' => '/found'}, ''] }
-          stub.new_stub(method, '/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
-        end.run_request(method, '/redirect', nil, nil).body).to eq 'fin'
-      end
-    end
-
-    [:put, :post, :patch].each do |method|
-      it "forwards request body for a #{method.to_s.upcase} request" do
-        conn = connection do |stub|
-          stub.new_stub(method, '/redirect') {
-            [status_code, {'Location' => '/found'}, '']
-          }
-          stub.new_stub(method, '/found') { |env|
-            [200, {'Content-Type' => 'text/plain'}, env[:body]]
-          }
-        end
-
-        response = conn.run_request(method, '/redirect', 'original data', nil)
-        expect(response.body).to eq('original data')
-      end
-    end
-  end
-
-
-  it "returns non-redirect response results" do
-    expect(connection do |stub|
-      stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
-    end.get('/found').body).to eq 'fin'
-  end
-
-  it "follows a single redirection" do
-    expect(connection do |stub|
-      stub.get('/')      { [301, {'Location' => '/found'}, ''] }
-      stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
-    end.get('/').body).to eq 'fin'
-  end
-
-  it "follows many redirections" do
-    expect(connection do |stub|
-      stub.get('/')          { [301, {'Location' => '/redirect1'}, ''] }
-      stub.get('/redirect1') { [301, {'Location' => '/redirect2'}, ''] }
-      stub.get('/redirect2') { [301, {'Location' => '/found'}, ''] }
-      stub.get('/found')     { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
-    end.get('/').body).to eq 'fin'
-  end
-
-  it "raises a FaradayMiddleware::RedirectLimitReached after 3 redirections (by default)" do
-    conn = connection do |stub|
-      stub.get('/')          { [301, {'Location' => '/redirect1'}, ''] }
-      stub.get('/redirect1') { [301, {'Location' => '/redirect2'}, ''] }
-      stub.get('/redirect2') { [301, {'Location' => '/redirect3'}, ''] }
-      stub.get('/redirect3') { [301, {'Location' => '/found'}, ''] }
-      stub.get('/found')     { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
-    end
-
-    expect{ conn.get('/') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
-  end
-
-  it "raises a FaradayMiddleware::RedirectLimitReached after the initialized limit" do
-    conn = connection(:limit => 1) do |stub|
-      stub.get('/')          { [301, {'Location' => '/redirect1'}, ''] }
-      stub.get('/redirect1') { [301, {'Location' => '/found'}, ''] }
-      stub.get('/found')     { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
-    end
-
-    expect{ conn.get('/') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
-  end
-
-  context "when cookies option" do
-
-    let(:cookies) { 'cookie1=abcdefg; cookie2=1234567; cookie3=awesome' }
-
-    context "is :all" do
-      it "puts all cookies from the response into the next request" do
-        expect(connection(:cookies => :all) do |stub|
-          stub.get('/')           { [301, {'Location' => '/found', 'Cookies' => cookies }, ''] }
-          stub.get('/found')      { [200, {'Content-Type' => 'text/plain'}, ''] }
-        end.get('/').env[:request_headers][:cookies]).to eq(cookies)
-      end
-
-      it "not set cookies header on request when response has no cookies" do
-        expect(connection(:cookies => :all) do |stub|
-          stub.get('/')           { [301, {'Location' => '/found'}, ''] }
-          stub.get('/found')      { [200, {'Content-Type' => 'text/plain'}, ''] }
-        end.get('/').env[:request_headers].has_key?('Cookies')).to eq(false)
-      end
-    end
-
-    context "is an array of cookie names" do
-      it "puts selected cookies from the response into the next request" do
-        expect(connection(:cookies => ['cookie2']) do |stub|
-          stub.get('/')           { [301, {'Location' => '/found', 'Cookies' => cookies }, ''] }
-          stub.get('/found')      { [200, {'Content-Type' => 'text/plain'}, ''] }
-        end.get('/').env[:request_headers][:cookies]).to eq('cookie2=1234567')
-      end
-    end
-  end
-
-  context "for an HTTP 301 response" do
-    it_behaves_like 'a successful redirection', 301
-    it_behaves_like 'a forced GET redirection', 301
-  end
-
-  context "for an HTTP 302 response" do
-    it_behaves_like 'a successful redirection', 302
-
-    context "by default" do
-      it_behaves_like 'a forced GET redirection', 302
-    end
-
-    context "with standards compliancy enabled" do
-      let(:middleware_options) { { :standards_compliant => true } }
-      it_behaves_like 'a replayed redirection', 302
-    end
-  end
-
-  context "for an HTTP 303 response" do
-    it_behaves_like 'a successful redirection', 303
-    it_behaves_like 'a forced GET redirection', 303
-  end
-
-  context "for an HTTP 307 response" do
-    it_behaves_like 'a successful redirection', 307
-    it_behaves_like 'a replayed redirection', 307
-  end
-
-  # checks env hash in request phase for basic validity
-  class Lint < Struct.new(:app)
-    def call(env)
-      if env[:status] or env[:response] or env[:response_headers]
-        raise "invalid request: #{env.inspect}"
-      end
-      if defined?(Faraday::Env) && !env.is_a?(Faraday::Env)
-        raise "expected Faraday::Env, got #{env.class}"
-      end
-      app.call(env)
-    end
-  end
-
-  private
-
-  def connection(options = middleware_options)
-    Faraday.new do |c|
-      c.use described_class, options
-      c.use Lint
-      c.adapter :test do |stub|
-        yield(stub) if block_given?
-      end
-    end
-  end
-end

data/spec/helper.rb

@@ -1,59 +0,0 @@
-if ENV['COVERAGE']
-  require 'simplecov'
-
-  SimpleCov.formatter = Class.new do
-    def format(result)
-      SimpleCov::Formatter::HTMLFormatter.new.format(result) unless ENV['CI']
-      File.open('coverage/covered_percent', 'w') do |f|
-        f.printf "%.2f", result.source_files.covered_percent
-      end
-    end
-  end
-
-  SimpleCov.start do
-    # add_filter 'faraday_middleware.rb'
-    add_filter 'backwards_compatibility.rb'
-  end
-end
-
-require 'rspec'
-require 'faraday'
-
-module EnvCompatibility
-  def faraday_env(env)
-    if defined?(Faraday::Env)
-      Faraday::Env.from(env)
-    else
-      env
-    end
-  end
-end
-
-module ResponseMiddlewareExampleGroup
-  def self.included(base)
-    base.let(:options) { Hash.new }
-    base.let(:headers) { Hash.new }
-    base.let(:middleware) {
-      described_class.new(lambda {|env|
-        Faraday::Response.new(env)
-      }, options)
-    }
-  end
-
-  def process(body, content_type = nil, options = {})
-    env = {
-      :body => body, :request => options,
-      :response_headers => Faraday::Utils::Headers.new(headers)
-    }
-    env[:response_headers]['content-type'] = content_type if content_type
-    middleware.call(faraday_env(env))
-  end
-end
-
-RSpec.configure do |config|
-  config.include EnvCompatibility
-  config.include ResponseMiddlewareExampleGroup, :type => :response
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end

data/spec/mashify_spec.rb

@@ -1,70 +0,0 @@
-require 'helper'
-require 'faraday_middleware/response/mashify'
-
-describe FaradayMiddleware::Mashify do
-  MyMash = Struct.new(:body)
-
-  context "when used", :type => :response do
-    it "creates a Hashie::Mash from the body" do
-      body = { "name" => "Erik Michaels-Ober", "username" => "sferik" }
-      me = process(body).body
-      expect(me.name).to eq("Erik Michaels-Ober")
-      expect(me.username).to eq("sferik")
-    end
-
-    it "handles strings" do
-      body = "Most amazing string EVER"
-      me = process(body).body
-      expect(me).to eq("Most amazing string EVER")
-    end
-
-    it "handles arrays" do
-      body = [123, 456]
-      values = process(body).body
-      expect(values).to eq([123, 456])
-    end
-
-    it "handles arrays of hashes" do
-      body = [{ "username" => "sferik" }, { "username" => "pengwynn" }]
-      us = process(body).body
-      expect(us.first.username).to eq('sferik')
-      expect(us.last.username).to eq('pengwynn')
-    end
-
-    it "handles nested arrays of hashes" do
-      body = [[{ "username" => "sferik" }, { "username" => "pengwynn" }]]
-      us = process(body).body.first
-      expect(us.first.username).to eq('sferik')
-      expect(us.last.username).to eq('pengwynn')
-    end
-
-    it "handles mixed arrays" do
-      body = [123, { "username" => "sferik" }, 456]
-      values = process(body).body
-      expect(values.first).to eq(123)
-      expect(values.last).to eq(456)
-      expect(values[1].username).to eq('sferik')
-    end
-
-    it "allows for use of custom Mash subclasses at the class level" do
-      original_class = described_class.mash_class
-      described_class.mash_class = MyMash
-
-      begin
-        me = process({}).body
-        expect(me).to be_instance_of(MyMash)
-      ensure
-        described_class.mash_class = original_class
-      end
-    end
-  end
-
-  context "custom mash subclass", :type => :response do
-    let(:options) { {:mash_class => MyMash} }
-
-    it "instance level" do
-      me = process({}).body
-        expect(me).to be_instance_of(MyMash)
-    end
-  end
-end

data/spec/method_override_spec.rb

@@ -1,92 +0,0 @@
-require 'helper'
-require 'faraday_middleware/request/method_override'
-
-describe FaradayMiddleware::MethodOverride do
-
-  let(:middleware) { described_class.new(lambda {|env| env }, *options) }
-  let(:env) { middleware.call faraday_env(request_env(request_method)) }
-
-  def request_env(method)
-    { :method => method,
-      :request_headers => Faraday::Utils::Headers.new
-    }
-  end
-
-  shared_examples "overrides method" do |method|
-    it "sets physical method to POST" do
-      expect(env[:method]).to eq(:post)
-    end
-
-    it "sets header to #{method}" do
-      expect(env[:request_headers]['X-Http-Method-Override']).to eq(method)
-    end
-  end
-
-  shared_examples "doesn't override method" do |method|
-    it "keeps original method" do
-      expect(env[:method]).to eq(method)
-    end
-
-    it "doesn't set header value" do
-      expect(env[:request_headers]).not_to have_key('X-Http-Method-Override')
-    end
-
-  end
-
-  context "with default options" do
-    let(:options) { nil }
-
-    context "GET" do
-      let(:request_method) { :get }
-      include_examples "doesn't override method", :get
-    end
-
-    context "POST" do
-      let(:request_method) { :post }
-      include_examples "doesn't override method", :post
-    end
-
-    context "PUT" do
-      let(:request_method) { :put }
-      include_examples "overrides method", 'PUT'
-    end
-  end
-
-  context "configured to rewrite [:patch, :delete]" do
-    let(:options) { [{ :rewrite => [:patch, :delete] }] }
-
-    context "PUT" do
-      let(:request_method) { :put }
-      include_examples "doesn't override method", :put
-    end
-
-    context "PATCH" do
-      let(:request_method) { :patch }
-      include_examples "overrides method", 'PATCH'
-    end
-
-    context "DELETE" do
-      let(:request_method) { :delete }
-      include_examples "overrides method", 'DELETE'
-    end
-  end
-
-  context "configured to rewrite ['PATCH']" do
-    let(:options) { [{ :rewrite => %w[PATCH] }] }
-
-    context "PATCH" do
-      let(:request_method) { :patch }
-      include_examples "overrides method", 'PATCH'
-    end
-  end
-
-  context "with invalid option" do
-    let(:options) { [{ :hello => 'world' }] }
-    let(:request_method) { :get }
-
-    it "raises key error" do
-      expect{ env }.to raise_error(IndexError, /key [\s\w]*not found/)
-    end
-  end
-
-end