faraday_middleware 0.7.0 → 0.8.0

data/spec/encode_json_spec.rb

@@ -0,0 +1,95 @@
+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(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
+      result_body.should be_nil
+    end
+
+    it "doesn't add content type" do
+      result_type.should be_nil
+    end
+  end
+
+  context "empty body" do
+    let(:result) { process('') }
+
+    it "doesn't change body" do
+      result_body.should be_empty
+    end
+
+    it "doesn't add content type" do
+      result_type.should be_nil
+    end
+  end
+
+  context "string body" do
+    let(:result) { process('{"a":1}') }
+
+    it "doesn't change body" do
+      result_body.should eql('{"a":1}')
+    end
+
+    it "adds content type" do
+      result_type.should eql('application/json')
+    end
+  end
+
+  context "object body" do
+    let(:result) { process({:a => 1}) }
+
+    it "encodes body" do
+      result_body.should eql('{"a":1}')
+    end
+
+    it "adds content type" do
+      result_type.should eql('application/json')
+    end
+  end
+
+  context "empty object body" do
+    let(:result) { process({}) }
+
+    it "encodes body" do
+      result_body.should eql('{}')
+    end
+  end
+
+  context "object body with json type" do
+    let(:result) { process({:a => 1}, 'application/json; charset=utf-8') }
+
+    it "encodes body" do
+      result_body.should eql('{"a":1}')
+    end
+
+    it "doesn't change content type" do
+      result_type.should eql('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
+      result_body.should eql({:a => 1})
+    end
+
+    it "doesn't change content type" do
+      result_type.should eql('application/xml; charset=utf-8')
+    end
+  end
+end

data/spec/follow_redirects_spec.rb

@@ -0,0 +1,33 @@
+require 'helper'
+require 'faraday_middleware/response/follow_redirects'
+require 'faraday'
+require 'forwardable'
+
+describe FaradayMiddleware::FollowRedirects do
+  let(:connection) {
+    Faraday.new do |c|
+      c.use described_class
+      c.adapter :test do |stub|
+        stub.get('/')        { [301, {'Location' => '/found'}, ''] }
+        stub.post('/create') { [302, {'Location' => '/'}, ''] }
+        stub.get('/found')   { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+        stub.get('/loop')    { [302, {'Location' => '/loop'}, ''] }
+      end
+    end
+  }
+
+  extend Forwardable
+  def_delegators :connection, :get, :post
+
+  it "follows redirect" do
+    get('/').body.should eql('fin')
+  end
+
+  it "follows redirect twice" do
+    post('/create').body.should eql('fin')
+  end
+
+  it "raises exception on loop" do
+    expect { get('/loop') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
+  end
+end

data/spec/helper.rb

@@ -1,18 +1,33 @@
-$:.unshift File.expand_path('..', __FILE__)
-$:.unshift File.expand_path('../../lib', __FILE__)
-require 'simplecov'
-SimpleCov.start
-require 'faraday_middleware'
-require 'rspec'
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start do
+    # add_filter 'faraday_middleware.rb'
+    add_filter 'backwards_compatibility.rb'
+  end
+end
 
-class DummyApp
-  attr_accessor :env
+require 'rspec'
 
-  def call(env)
-    @env = env
+module ResponseMiddlewareExampleGroup
+  def self.included(base)
+    base.let(:options) { Hash.new }
+    base.let(:middleware) {
+      described_class.new(lambda {|env|
+        Faraday::Response.new(env)
+      }, options)
+    }
   end
 
-  def reset
-    @env = nil
+  def process(body, content_type = nil, options = {})
+    env = {
+      :body => body, :request => options,
+      :response_headers => Faraday::Utils::Headers.new
+    }
+    env[:response_headers]['content-type'] = content_type if content_type
+    middleware.call(env)
   end
 end
+
+RSpec.configure do |config|
+  config.include ResponseMiddlewareExampleGroup, :type => :response
+end

data/spec/mashify_spec.rb

@@ -1,16 +1,17 @@
 require 'helper'
+require 'faraday_middleware/response/mashify'
 
-describe Faraday::Response::Mashify do
+describe FaradayMiddleware::Mashify do
   context 'during configuration' do
     it 'should allow for a custom Mash class to be set' do
-      Faraday::Response::Mashify.should respond_to(:mash_class)
-      Faraday::Response::Mashify.should respond_to(:mash_class=)
+      described_class.should respond_to(:mash_class)
+      described_class.should respond_to(:mash_class=)
     end
   end
 
   context 'when used' do
-    before(:each) { Faraday::Response::Mashify.mash_class = ::Hashie::Mash }
-    let(:mashify) { Faraday::Response::Mashify.new }
+    before(:each) { described_class.mash_class = ::Hashie::Mash }
+    let(:mashify) { described_class.new }
 
     it 'should create a Hashie::Mash from the body' do
       env = { :body => { "name" => "Erik Michaels-Ober", "username" => "sferik" } }
@@ -48,7 +49,7 @@ describe Faraday::Response::Mashify do
 
     it 'should allow for use of custom Mash subclasses' do
       class MyMash < ::Hashie::Mash; end
-      Faraday::Response::Mashify.mash_class = MyMash
+      described_class.mash_class = MyMash
 
       env = { :body => { "name" => "Erik Michaels-Ober", "username" => "sferik" } }
       me  = mashify.on_complete(env)
@@ -62,7 +63,7 @@ describe Faraday::Response::Mashify do
     let(:connection) do
       Faraday::Connection.new do |builder|
         builder.adapter :test, stubs
-        builder.use Faraday::Response::Mashify
+        builder.use described_class
       end
     end
 

data/spec/oauth2_spec.rb

@@ -1,50 +1,118 @@
 require 'helper'
+require 'uri'
+require 'faraday_middleware/request/oauth2'
+require 'faraday/utils'
 
-describe Faraday::Request::OAuth2 do
+describe FaradayMiddleware::OAuth2 do
 
-  context 'when used with a access token in the initializer' do
-    let(:oauth2) { Faraday::Request::OAuth2.new(DummyApp.new, '1234') }
+  def query_params(env)
+    Faraday::Utils.parse_query env[:url].query
+  end
+
+  def auth_header(env)
+    env[:request_headers]['Authorization']
+  end
+
+  def perform(params = {}, headers = {})
+    env = {
+      :url => URI('http://example.com/?' + Faraday::Utils.build_query(params)),
+      :request_headers => Faraday::Utils::Headers.new.update(headers)
+    }
+    app = make_app
+    app.call(env)
+  end
 
-    it 'should add the access token to the request' do
-      env = {
-        :request_headers => {},
-        :url => Addressable::URI.parse('http://www.github.com')
-      }
+  def make_app
+    described_class.new(lambda{|env| env}, *Array(options))
+  end
+
+  context "no token configured" do
+    let(:options) { nil }
+
+    it "doesn't add params" do
+      request = perform(:q => 'hello')
+      query_params(request).should eq('q' => 'hello')
+    end
 
-      request = oauth2.call(env)
-      request[:request_headers]["Authorization"].should == "Token token=\"1234\""
-      request[:url].query_values["access_token"].should == "1234"
+    it "doesn't add headers" do
+      auth_header(perform).should be_nil
+    end
+
+    it "creates header for explicit token" do
+      request = perform(:q => 'hello', :access_token => 'abc123')
+      query_params(request).should eq('q' => 'hello', 'access_token' => 'abc123')
+      auth_header(request).should eq(%(Token token="abc123"))
     end
   end
 
-  context 'when used with a access token in the query_values' do
-    let(:oauth2) { Faraday::Request::OAuth2.new(DummyApp.new) }
+  context "default token configured" do
+    let(:options) { 'XYZ' }
+
+    it "adds token param" do
+      query_params(perform(:q => 'hello')).should eq('q' => 'hello', 'access_token' => 'XYZ')
+    end
+
+    it "adds token header" do
+      auth_header(perform).should eq(%(Token token="XYZ"))
+    end
 
-    it 'should add the access token to the request' do
-      env = {
-        :request_headers => {},
-        :url => Addressable::URI.parse('http://www.github.com/?access_token=1234')
-      }
+    it "overrides default with explicit token" do
+      request = perform(:q => 'hello', :access_token => 'abc123')
+      query_params(request).should eq('q' => 'hello', 'access_token' => 'abc123')
+      auth_header(request).should eq(%(Token token="abc123"))
+    end
 
-      request = oauth2.call(env)
-      request[:request_headers]["Authorization"].should == "Token token=\"1234\""
-      request[:url].query_values["access_token"].should == "1234"
+    it "clears default with empty explicit token" do
+      request = perform(:q => 'hello', :access_token => nil)
+      query_params(request).should eq('q' => 'hello', 'access_token' => nil)
+      auth_header(request).should be_nil
     end
   end
 
-  context 'integration test' do
-    let(:stubs) { Faraday::Adapter::Test::Stubs.new }
-    let(:connection) do
-      Faraday::Connection.new do |builder|
-        builder.use Faraday::Request::OAuth2, '1234'
-        builder.adapter :test, stubs
-      end
+  context "existing Authorization header" do
+    let(:options) { 'XYZ' }
+    subject { perform({:q => 'hello'}, 'Authorization' => 'custom') }
+
+    it "adds token param" do
+      query_params(subject).should eq('q' => 'hello', 'access_token' => 'XYZ')
     end
 
-    it 'should add the access token to the query string' do
-      stubs.get('/me?access_token=1234') {[200, {}, 'sferik']}
-      me = connection.get('/me')
-      me.body.should == 'sferik'
+    it "doesn't override existing header" do
+      auth_header(subject).should eq('custom')
+    end
+  end
+
+  context "custom param name configured" do
+    let(:options) { ['XYZ', {:param_name => :oauth}] }
+
+    it "adds token param" do
+      query_params(perform).should eq('oauth' => 'XYZ')
+    end
+
+    it "overrides default with explicit token" do
+      request = perform(:oauth => 'abc123')
+      query_params(request).should eq('oauth' => 'abc123')
+      auth_header(request).should eq(%(Token token="abc123"))
+    end
+  end
+
+  context "options without token configuration" do
+    let(:options) { [{:param_name => :oauth}] }
+
+    it "doesn't add param" do
+      query_params(perform).should be_empty
+    end
+
+    it "overrides default with explicit token" do
+      query_params(perform(:oauth => 'abc123')).should eq('oauth' => 'abc123')
+    end
+  end
+
+  context "invalid param name configured" do
+    let(:options) { ['XYZ', {:param_name => nil}] }
+
+    it "raises error" do
+      expect { make_app }.to raise_error(ArgumentError, ":param_name can't be blank")
     end
   end
 end

data/spec/oauth_spec.rb

@@ -1,46 +1,101 @@
 require 'helper'
+require 'faraday_middleware/request/oauth'
+require 'uri'
 
-describe Faraday::Request::OAuth do
-  OAUTH_HEADER_REGEX = /^OAuth oauth_consumer_key=\"\d{4}\", oauth_nonce=\".+\", oauth_signature=\".+\", oauth_signature_method=\"HMAC-SHA1\", oauth_timestamp=\"\d{10}\", oauth_token=\"\d{4}\", oauth_version=\"1\.0\"/
+describe FaradayMiddleware::OAuth do
+  def auth_header(env)
+    env[:request_headers]['Authorization']
+  end
+
+  def auth_values(env)
+    if auth = auth_header(env)
+      raise "invalid header: #{auth.inspect}" unless auth.sub!('OAuth ', '')
+      Hash[*auth.split(/, |=/)]
+    end
+  end
 
-  let(:config) do
-    {
-      :consumer_key => '1234',
-      :consumer_secret => '1234',
-      :token => '1234',
-      :token_secret => '1234'
+  def perform(oauth_options = {}, headers = {})
+    env = {
+      :url => URI('http://example.com/'),
+      :request_headers => Faraday::Utils::Headers.new.update(headers),
+      :request => {}
     }
+    unless oauth_options.is_a? Hash and oauth_options.empty?
+      env[:request][:oauth] = oauth_options
+    end
+    app = make_app
+    app.call(env)
   end
 
-  context 'when used' do
-    let(:oauth) { Faraday::Request::OAuth.new(DummyApp.new, config) }
+  def make_app
+    described_class.new(lambda{|env| env}, *Array(options))
+  end
 
-    let(:env) do
-      { :request_headers => {}, :url => Addressable::URI.parse('http://www.github.com') }
+  context "invalid options" do
+    let(:options) { nil }
+
+    it "should error out" do
+      expect { make_app }.to raise_error(ArgumentError)
     end
+  end
+
+  context "empty options" do
+    let(:options) { [{}] }
 
-    it 'should add the access token to the header' do
-      request = oauth.call(env)
-      request[:request_headers]["Authorization"].should match OAUTH_HEADER_REGEX
+    it "should sign request" do
+      auth = auth_values(perform)
+      expected_keys = %w[ oauth_nonce
+                          oauth_signature oauth_signature_method
+                          oauth_timestamp oauth_version ]
+
+      auth.keys.should =~ expected_keys
     end
   end
 
+  context "configured with consumer and token" do
+    let(:options) do
+      [{ :consumer_key => 'CKEY', :consumer_secret => 'CSECRET',
+         :token => 'TOKEN', :token_secret => 'TSECRET'
+      }]
+    end
 
-  context 'integration test' do
-    let(:stubs) { Faraday::Adapter::Test::Stubs.new }
-    let(:connection) do
-      Faraday::Connection.new do |builder|
-        builder.use Faraday::Request::OAuth, config
-        builder.adapter :test, stubs
-      end
+    it "adds auth info to the header" do
+      auth = auth_values(perform)
+      expected_keys = %w[ oauth_consumer_key oauth_nonce
+                          oauth_signature oauth_signature_method
+                          oauth_timestamp oauth_token oauth_version ]
+
+      auth.keys.should =~ expected_keys
+      auth['oauth_version'].should eq(%("1.0"))
+      auth['oauth_signature_method'].should eq(%("HMAC-SHA1"))
+      auth['oauth_consumer_key'].should eq(%("CKEY"))
+      auth['oauth_token'].should eq(%("TOKEN"))
+    end
+
+    it "doesn't override existing header" do
+      request = perform({}, "Authorization" => "iz me!")
+      auth_header(request).should eq("iz me!")
+    end
+
+    it "can override oauth options per-request" do
+      auth = auth_values(perform(:consumer_key => 'CKEY2'))
+
+      auth['oauth_consumer_key'].should eq(%("CKEY2"))
+      auth['oauth_token'].should eq(%("TOKEN"))
+    end
+
+    it "can turn off oauth signing per-request" do
+      auth_header(perform(false)).should be_nil
     end
+  end
+
+  context "configured without token" do
+    let(:options) { [{ :consumer_key => 'CKEY', :consumer_secret => 'CSECRET' }] }
 
-    # Sadly we can not check the headers in this integration test, but this will
-    # confirm that the middleware doesn't break the stack
-    it 'should add the access token to the query string' do
-      stubs.get('/me') {[200, {}, 'sferik']}
-      me = connection.get('http://www.github.com/me')
-      me.body.should == 'sferik'
+    it "adds auth info to the header" do
+      auth = auth_values(perform)
+      auth.should include('oauth_consumer_key')
+      auth.should_not include('oauth_token')
     end
   end
 end