agiley-faraday_middleware 0.8.3

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

@@ -0,0 +1,33 @@
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start do
+    # add_filter 'faraday_middleware.rb'
+    add_filter 'backwards_compatibility.rb'
+  end
+end
+
+require 'rspec'
+
+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 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

@@ -0,0 +1,79 @@
+require 'helper'
+require 'faraday_middleware/response/mashify'
+
+describe FaradayMiddleware::Mashify do
+  context 'during configuration' do
+    it 'should allow for a custom Mash class to be set' do
+      described_class.should respond_to(:mash_class)
+      described_class.should respond_to(:mash_class=)
+    end
+  end
+
+  context 'when used' do
+    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" } }
+      me  = mashify.on_complete(env)
+      me.class.should == Hashie::Mash
+    end
+
+    it 'should handle strings' do
+      env = { :body => "Most amazing string EVER" }
+      me  = mashify.on_complete(env)
+      me.should == "Most amazing string EVER"
+    end
+
+    it 'should handle arrays' do
+      env = { :body => [123, 456] }
+      values = mashify.on_complete(env)
+      values.first.should == 123
+      values.last.should == 456
+    end
+
+    it 'should handle arrays of hashes' do
+      env = { :body => [{ "username" => "sferik" }, { "username" => "pengwynn" }] }
+      us  = mashify.on_complete(env)
+      us.first.username.should == 'sferik'
+      us.last.username.should == 'pengwynn'
+    end
+
+    it 'should handle mixed arrays' do
+      env = { :body => [123, { "username" => "sferik" }, 456] }
+      values = mashify.on_complete(env)
+      values.first.should == 123
+      values.last.should == 456
+      values[1].username.should == 'sferik'
+    end
+
+    it 'should allow for use of custom Mash subclasses' do
+      class MyMash < ::Hashie::Mash; end
+      described_class.mash_class = MyMash
+
+      env = { :body => { "name" => "Erik Michaels-Ober", "username" => "sferik" } }
+      me  = mashify.on_complete(env)
+
+      me.class.should == MyMash
+    end
+  end
+
+  context 'integration test' do
+    let(:stubs) { Faraday::Adapter::Test::Stubs.new }
+    let(:connection) do
+      Faraday::Connection.new do |builder|
+        builder.adapter :test, stubs
+        builder.use described_class
+      end
+    end
+
+    # although it is not good practice to pass a hash as the body, if we add ParseJson
+    # to the middleware stack we end up testing two middlewares instead of one
+    it 'should create a Hash from the body' do
+      stubs.get('/hash') {[200, {'content-type' => 'application/json; charset=utf-8'}, { "name" => "Erik Michaels-Ober", "username" => "sferik" }]}
+      me = connection.get('/hash').body
+      me.name.should == 'Erik Michaels-Ober'
+      me.username.should == 'sferik'
+    end
+  end
+end

data/spec/oauth2_spec.rb

@@ -0,0 +1,118 @@
+require 'helper'
+require 'uri'
+require 'faraday_middleware/request/oauth2'
+require 'faraday/utils'
+
+describe FaradayMiddleware::OAuth2 do
+
+  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
+
+  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
+
+    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 "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 "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
+
+    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 "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 "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

@@ -0,0 +1,101 @@
+require 'helper'
+require 'faraday_middleware/request/oauth'
+require 'uri'
+
+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
+
+  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
+
+  def make_app
+    described_class.new(lambda{|env| env}, *Array(options))
+  end
+
+  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 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
+
+    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' }] }
+
+    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