faraday_middleware 0.9.1 → 1.2.0

data/spec/oauth2_spec.rb

@@ -1,118 +0,0 @@
-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(faraday_env(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')
-      expect(query_params(request)).to eq('q' => 'hello')
-    end
-
-    it "doesn't add headers" do
-      expect(auth_header(perform)).to be_nil
-    end
-
-    it "creates header for explicit token" do
-      request = perform(:q => 'hello', :access_token => 'abc123')
-      expect(query_params(request)).to eq('q' => 'hello', 'access_token' => 'abc123')
-      expect(auth_header(request)).to eq(%(Token token="abc123"))
-    end
-  end
-
-  context "default token configured" do
-    let(:options) { 'XYZ' }
-
-    it "adds token param" do
-      expect(query_params(perform(:q => 'hello'))).to eq('q' => 'hello', 'access_token' => 'XYZ')
-    end
-
-    it "adds token header" do
-      expect(auth_header(perform)).to eq(%(Token token="XYZ"))
-    end
-
-    it "overrides default with explicit token" do
-      request = perform(:q => 'hello', :access_token => 'abc123')
-      expect(query_params(request)).to eq('q' => 'hello', 'access_token' => 'abc123')
-      expect(auth_header(request)).to eq(%(Token token="abc123"))
-    end
-
-    it "clears default with empty explicit token" do
-      request = perform(:q => 'hello', :access_token => nil)
-      expect(query_params(request).fetch('access_token')).to_not eq('XYZ')
-      expect(auth_header(request)).to be_nil
-    end
-  end
-
-  context "existing Authorization header" do
-    let(:options) { 'XYZ' }
-    subject { perform({:q => 'hello'}, 'Authorization' => 'custom') }
-
-    it "adds token param" do
-      expect(query_params(subject)).to eq('q' => 'hello', 'access_token' => 'XYZ')
-    end
-
-    it "doesn't override existing header" do
-      expect(auth_header(subject)).to eq('custom')
-    end
-  end
-
-  context "custom param name configured" do
-    let(:options) { ['XYZ', {:param_name => :oauth}] }
-
-    it "adds token param" do
-      expect(query_params(perform)).to eq('oauth' => 'XYZ')
-    end
-
-    it "overrides default with explicit token" do
-      request = perform(:oauth => 'abc123')
-      expect(query_params(request)).to eq('oauth' => 'abc123')
-      expect(auth_header(request)).to eq(%(Token token="abc123"))
-    end
-  end
-
-  context "options without token configuration" do
-    let(:options) { [{:param_name => :oauth}] }
-
-    it "doesn't add param" do
-      expect(query_params(perform)).to be_empty
-    end
-
-    it "overrides default with explicit token" do
-      expect(query_params(perform(:oauth => 'abc123'))).to 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,151 +0,0 @@
-require 'helper'
-require 'faraday_middleware/request/oauth'
-require 'uri'
-require 'forwardable'
-
-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 = {}, params = {})
-    env = {
-      :url => URI('http://example.com/'),
-      :request_headers => Faraday::Utils::Headers.new.update(headers),
-      :request => {},
-      :body => params
-    }
-    unless oauth_options.is_a? Hash and oauth_options.empty?
-      env[:request][:oauth] = oauth_options
-    end
-    app = make_app
-    app.call(faraday_env(env))
-  end
-
-  def make_app
-    described_class.new(lambda{|env| env}, *Array(options))
-  end
-
-  context "invalid options" do
-    let(:options) { nil }
-
-    it "errors out" do
-      expect{ make_app }.to raise_error(ArgumentError)
-    end
-  end
-
-  context "empty options" do
-    let(:options) { [{}] }
-
-    it "signs request" do
-      auth = auth_values(perform)
-      expected_keys = %w[ oauth_nonce
-                          oauth_signature oauth_signature_method
-                          oauth_timestamp oauth_version ]
-
-      expect(auth.keys).to match_array 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 ]
-
-      expect(auth.keys).to match_array expected_keys
-      expect(auth['oauth_version']).to eq(%("1.0"))
-      expect(auth['oauth_signature_method']).to eq(%("HMAC-SHA1"))
-      expect(auth['oauth_consumer_key']).to eq(%("CKEY"))
-      expect(auth['oauth_token']).to eq(%("TOKEN"))
-    end
-
-    it "doesn't override existing header" do
-      request = perform({}, "Authorization" => "iz me!")
-      expect(auth_header(request)).to eq("iz me!")
-    end
-
-    it "can override oauth options per-request" do
-      auth = auth_values(perform(:consumer_key => 'CKEY2'))
-
-      expect(auth['oauth_consumer_key']).to eq(%("CKEY2"))
-      expect(auth['oauth_token']).to eq(%("TOKEN"))
-    end
-
-    it "can turn off oauth signing per-request" do
-      expect(auth_header(perform(false))).to 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)
-      expect(auth).to include('oauth_consumer_key')
-      expect(auth).not_to include('oauth_token')
-    end
-  end
-
-  context "handling body parameters" do
-    let(:options) { [{ :consumer_key => 'CKEY',
-                       :consumer_secret => 'CSECRET',
-                       :nonce => '547fed103e122eecf84c080843eedfe6',
-                       :timestamp => '1286830180'}] }
-
-    let(:value) { {'foo' => 'bar'} }
-
-    let(:type_json) { {'Content-Type' => 'application/json'} }
-    let(:type_form) { {'Content-Type' => 'application/x-www-form-urlencoded'} }
-
-    extend Forwardable
-    query_method = :build_nested_query
-    query_module = ::Faraday::Utils.respond_to?(query_method) ? 'Faraday::Utils' : 'Rack::Utils'
-    def_delegator query_module, query_method
-
-    it "does not include the body for JSON" do
-      auth_header_with    = auth_header(perform({}, type_json, '{"foo":"bar"}'))
-      auth_header_without = auth_header(perform({}, type_json, {}))
-
-      expect(auth_header_with).to eq(auth_header_without)
-    end
-
-    it "includes the body parameters with form Content-Type" do
-      auth_header_with    = auth_header(perform({}, type_form, {}))
-      auth_header_without = auth_header(perform({}, type_form, value))
-
-      expect(auth_header_with).not_to eq(auth_header_without)
-    end
-
-    it "includes the body parameters with an unspecified Content-Type" do
-      auth_header_with    = auth_header(perform({}, {}, value))
-      auth_header_without = auth_header(perform({}, type_form, value))
-
-      expect(auth_header_with).to eq(auth_header_without)
-    end
-
-    it "includes the body parameters for form type with string body" do
-      # simulates the behavior of Faraday::MiddleWare::UrlEncoded
-      value = { 'foo' => ['bar', 'baz', 'wat'] }
-      auth_header_hash   = auth_header(perform({}, type_form, value))
-      auth_header_string = auth_header(perform({}, type_form, build_nested_query(value)))
-      expect(auth_header_string).to eq(auth_header_hash)
-    end
-
-  end
-
-end

data/spec/parse_dates_spec.rb

@@ -1,44 +0,0 @@
-require 'helper'
-require 'faraday_middleware/response/parse_dates'
-require 'json'
-
-describe FaradayMiddleware::ParseDates, :type => :response do
-  let(:parsed){
-    if RUBY_VERSION > "1.9"
-      "2012-02-01 13:14:15 UTC"
-    else
-      "Wed Feb 01 13:14:15 UTC 2012"
-    end
-  }
-
-  it "parses dates" do
-    expect(process({"x" => "2012-02-01T13:14:15Z"}).body["x"].to_s).to eq(parsed)
-  end
-
-  it "parses dates with milliseconds" do
-    date_str = "2012-02-01T13:14:15.123Z"
-    expect(process({"x" => date_str}).body["x"]).to eq(Time.parse(date_str))
-  end
-
-  it "parses nested dates in hash" do
-    expect(process({"x" => {"y" => "2012-02-01T13:14:15Z"}}).body["x"]["y"].to_s).to eq(parsed)
-  end
-
-  it "parses nested dates in arrays" do
-    expect(process({"x" => [{"y" =>"2012-02-01T13:14:15Z"}]}).body["x"][0]["y"].to_s).to eq(parsed)
-  end
-
-  it "returns nil when body is empty" do
-    expect(process(nil).body).to eq(nil)
-  end
-
-  it "leaves arrays with ids alone" do
-    expect(process({"x" => [1,2,3]}).body).to eq({"x" => [1,2,3]})
-  end
-
-  it "does not parse date-like things" do
-    expect(process({"x" => "2012-02-01T13:14:15Z bla"}).body["x"].to_s).to eq "2012-02-01T13:14:15Z bla"
-    expect(process({"x" => "12012-02-01T13:14:15Z"}).body["x"].to_s).to eq "12012-02-01T13:14:15Z"
-    expect(process({"x" => "2012-02-01T13:14:15Z\nfoo"}).body["x"].to_s).to eq "2012-02-01T13:14:15Z\nfoo"
-  end
-end

data/spec/parse_json_spec.rb

@@ -1,112 +0,0 @@
-require 'helper'
-require 'faraday_middleware/response/parse_json'
-
-describe FaradayMiddleware::ParseJson, :type => :response do
-  context "no type matching" do
-    it "doesn't change nil body" do
-      expect(process(nil).body).to be_nil
-    end
-
-    it "nullifies empty body" do
-      expect(process('').body).to be_nil
-    end
-
-    it "parses json body" do
-      response = process('{"a":1}')
-      expect(response.body).to eq('a' => 1)
-      expect(response.env[:raw_body]).to be_nil
-    end
-  end
-
-  context "with preserving raw" do
-    let(:options) { {:preserve_raw => true} }
-
-    it "parses json body" do
-      response = process('{"a":1}')
-      expect(response.body).to eq('a' => 1)
-      expect(response.env[:raw_body]).to eq('{"a":1}')
-    end
-
-    it "can opt out of preserving raw" do
-      response = process('{"a":1}', nil, :preserve_raw => false)
-      expect(response.env[:raw_body]).to be_nil
-    end
-  end
-
-  context "with regexp type matching" do
-    let(:options) { {:content_type => /\bjson$/} }
-
-    it "parses json body of correct type" do
-      response = process('{"a":1}', 'application/x-json')
-      expect(response.body).to eq('a' => 1)
-    end
-
-    it "ignores json body of incorrect type" do
-      response = process('{"a":1}', 'text/json-xml')
-      expect(response.body).to eq('{"a":1}')
-    end
-  end
-
-  context "with array type matching" do
-    let(:options) { {:content_type => %w[a/b c/d]} }
-
-    it "parses json body of correct type" do
-      expect(process('{"a":1}', 'a/b').body).to be_a(Hash)
-      expect(process('{"a":1}', 'c/d').body).to be_a(Hash)
-    end
-
-    it "ignores json body of incorrect type" do
-      expect(process('{"a":1}', 'a/d').body).not_to be_a(Hash)
-    end
-  end
-
-  it "chokes on invalid json" do
-    ['{!', '"a"', 'true', 'null', '1'].each do |data|
-      expect{ process(data) }.to raise_error(Faraday::Error::ParsingError)
-    end
-  end
-
-  context "with mime type fix" do
-    let(:middleware) {
-      app = described_class::MimeTypeFix.new(lambda {|env|
-        Faraday::Response.new(env)
-      }, :content_type => /^text\//)
-      described_class.new(app, :content_type => 'application/json')
-    }
-
-    it "ignores completely incompatible type" do
-      response = process('{"a":1}', 'application/xml')
-      expect(response.body).to eq('{"a":1}')
-    end
-
-    it "ignores compatible type with bad data" do
-      response = process('var a = 1', 'text/javascript')
-      expect(response.body).to eq('var a = 1')
-      expect(response['content-type']).to eq('text/javascript')
-    end
-
-    it "corrects compatible type and data" do
-      response = process('{"a":1}', 'text/javascript')
-      expect(response.body).to be_a(Hash)
-      expect(response['content-type']).to eq('application/json')
-    end
-
-    it "corrects compatible type even when data starts with whitespace" do
-      response = process(%( \r\n\t{"a":1}), 'text/javascript')
-      expect(response.body).to be_a(Hash)
-      expect(response['content-type']).to eq('application/json')
-    end
-  end
-
-  context "HEAD responses" do
-    it "nullifies the body if it's only one space" do
-      response = process(' ')
-      expect(response.body).to be_nil
-    end
-
-    it "nullifies the body if it's two spaces" do
-      response = process(' ')
-      expect(response.body).to be_nil
-    end
-  end
-end

data/spec/parse_marshal_spec.rb

@@ -1,16 +0,0 @@
-require 'helper'
-require 'faraday_middleware/response/parse_marshal'
-
-describe FaradayMiddleware::ParseMarshal, :type => :response do
-  it "restores a marshaled dump" do
-    expect(process(Marshal.dump(:a => 1)).body).to be_eql(:a => 1)
-  end
-
-  it "nulifies blank response" do
-    expect(process('').body).to be_nil
-  end
-
-  it "chokes on invalid content" do
-    expect{ process('abc') }.to raise_error(Faraday::Error::ParsingError)
-  end
-end

data/spec/parse_xml_spec.rb

@@ -1,71 +0,0 @@
-require 'helper'
-require 'faraday_middleware/response/parse_xml'
-
-describe FaradayMiddleware::ParseXml, :type => :response do
-  let(:xml)  { '<user><name>Erik Michaels-Ober</name><screen_name>sferik</screen_name></user>' }
-  let(:user) { {'user' => {'name' => 'Erik Michaels-Ober', 'screen_name' => 'sferik'} } }
-
-  context "no type matching" do
-    it "doesn't change nil body" do
-      expect(process(nil).body).to be_nil
-    end
-
-    it "turns empty body into empty hash" do
-      expect(process('').body).to be_eql({})
-    end
-
-    it "parses xml body" do
-      response = process(xml)
-      expect(response.body).to eq(user)
-      expect(response.env[:raw_body]).to be_nil
-    end
-  end
-
-  context "with preserving raw" do
-    let(:options) { {:preserve_raw => true} }
-
-    it "parses xml body" do
-      response = process(xml)
-      expect(response.body).to eq(user)
-      expect(response.env[:raw_body]).to eq(xml)
-    end
-
-    it "can opt out of preserving raw" do
-      response = process(xml, nil, :preserve_raw => false)
-      expect(response.env[:raw_body]).to be_nil
-    end
-  end
-
-  context "with regexp type matching" do
-    let(:options) { {:content_type => /\bxml$/} }
-
-    it "parses xml body of correct type" do
-      response = process(xml, 'application/xml')
-      expect(response.body).to eq(user)
-    end
-
-    it "ignores xml body of incorrect type" do
-      response = process(xml, 'text/html')
-      expect(response.body).to eq(xml)
-    end
-  end
-
-  context "with array type matching" do
-    let(:options) { {:content_type => %w[a/b c/d]} }
-
-    it "parses xml body of correct type" do
-      expect(process(xml, 'a/b').body).to be_a(Hash)
-      expect(process(xml, 'c/d').body).to be_a(Hash)
-    end
-
-    it "ignores xml body of incorrect type" do
-      expect(process(xml, 'a/d').body).not_to be_a(Hash)
-    end
-  end
-
-  it "chokes on invalid xml" do
-    ['{!', '"a"', 'true', 'null', '1'].each do |data|
-      expect{ process(data) }.to raise_error(Faraday::Error::ParsingError)
-    end
-  end
-end

data/spec/parse_yaml_spec.rb

@@ -1,53 +0,0 @@
-require 'helper'
-require 'faraday_middleware/response/parse_yaml'
-
-describe FaradayMiddleware::ParseYaml, :type => :response do
-  context "no type matching" do
-    it "doesn't change nil body" do
-      expect(process(nil).body).to be_nil
-    end
-
-    it "returns false for empty body" do
-      expect(process('').body).to be_false
-    end
-
-    it "parses yaml body" do
-      response = process('a: 1')
-      expect(response.body).to eq('a' => 1)
-      expect(response.env[:raw_body]).to be_nil
-    end
-  end
-
-  context "with preserving raw" do
-    let(:options) { {:preserve_raw => true} }
-
-    it "parses yaml body" do
-      response = process('a: 1')
-      expect(response.body).to eq('a' => 1)
-      expect(response.env[:raw_body]).to eq('a: 1')
-    end
-
-    it "can opt out of preserving raw" do
-      response = process('a: 1', nil, :preserve_raw => false)
-      expect(response.env[:raw_body]).to be_nil
-    end
-  end
-
-  context "with regexp type matching" do
-    let(:options) { {:content_type => /\byaml$/} }
-
-    it "parses json body of correct type" do
-      response = process('a: 1', 'application/x-yaml')
-      expect(response.body).to eq('a' => 1)
-    end
-
-    it "ignores json body of incorrect type" do
-      response = process('a: 1', 'text/yaml-xml')
-      expect(response.body).to eq('a: 1')
-    end
-  end
-
-  it "chokes on invalid yaml" do
-    expect{ process('{!') }.to raise_error(Faraday::Error::ParsingError)
-  end
-end

data/spec/rashify_spec.rb

@@ -1,47 +0,0 @@
-require 'helper'
-require 'faraday_middleware/response/rashify'
-
-describe FaradayMiddleware::Rashify do
-  context "when used", :type => :response do
-    it "creates a Hashie::Rash 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 hashes and decamelcase the keys" do
-      body = { "name" => "Erik Michaels-Ober", "userName" => "sferik" }
-      me = process(body).body
-      expect(me.name).to eq('Erik Michaels-Ober')
-      expect(me.user_name).to eq('sferik')
-    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 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
-  end
-end