Add support for Faraday and refactored/beautified the code

airborne.gemspec

@@ -15,5 +15,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'rack-test', '~> 0.6', '>= 0.6.2'
   s.add_runtime_dependency 'rack'
   s.add_runtime_dependency 'activesupport'
+  s.add_runtime_dependency 'faraday', '~> 0.13'
   s.add_development_dependency 'webmock', '~> 0'
+  s.add_development_dependency 'pry'
 end

lib/airborne.rb

@@ -1,27 +1,29 @@
+require 'airborne/rspec_settings'
 require 'airborne/optional_hash_type_expectations'
 require 'airborne/path_matcher'
 require 'airborne/request_expectations'
 require 'airborne/rest_client_requester'
 require 'airborne/rack_test_requester'
+require 'airborne/faraday_requester'
 require 'airborne/base'
 
-RSpec.configure do |config|
-  config.add_setting :base_url
-  config.add_setting :match_expected
-  config.add_setting :match_actual
-  config.add_setting :match_expected_default, default: true
-  config.add_setting :match_actual_default, default: false
-  config.add_setting :headers
-  config.add_setting :rack_app
-  config.add_setting :requester_type
-  config.add_setting :requester_module
-  config.before do |example|
-    config.match_expected = example.metadata[:match_expected].nil? ?
-      Airborne.configuration.match_expected_default? : example.metadata[:match_expected]
-    config.match_actual = example.metadata[:match_actual].nil? ?
-      Airborne.configuration.match_actual_default? : example.metadata[:match_actual]
+
+module Airborne
+  class << self
+    def configuration
+      RSpec.configuration
+    end
+
+    def configure
+      RSpec.configure do |config|
+        yield config
+      end
+    end
   end
+end
 
-  # Include last since it depends on the configuration already being added
-  config.include Airborne
+Airborne.configure do |config|
+  config.include Airborne::Base
+  config.filter_run_when_matching :focus
+  config.order = :random
 end

lib/airborne/base.rb

@@ -1,82 +1,82 @@
 require 'json'
 require 'active_support'
 require 'active_support/core_ext/hash/indifferent_access'
+require 'base64'
 
 module Airborne
-  class InvalidJsonError < StandardError; end
-
-  include RequestExpectations
-
-  attr_reader :response, :headers, :body
-
-  def self.configure
-    RSpec.configure do |config|
-      yield config
+  module Base
+    class InvalidJsonError < StandardError; end
+
+    include RequestExpectations
+
+    attr_reader :response, :headers, :body
+
+    def self.included(base)
+      if Airborne.configuration.use_faraday
+        base.send(:include, Airborne::FaradayRequester)
+      elsif Airborne.configuration.requester_module
+        base.send(:include, Airborne.configuration.requester_module)
+      elsif Airborne.configuration.rack_app
+        base.send(:include, RackTestRequester)
+      else
+        base.send(:include, RestClientRequester)
+      end
     end
-  end
 
-  def self.included(base)
-    if !Airborne.configuration.requester_module.nil?
-      base.send(:include, Airborne.configuration.requester_module)
-    elsif !Airborne.configuration.rack_app.nil?
-      base.send(:include, RackTestRequester)
-    else
-      base.send(:include, RestClientRequester)
+    def get(path, body = nil, headers = nil, &block)
+      @response = make_request(:get, path, body, headers, &block)
     end
-  end
-
-  def self.configuration
-    RSpec.configuration
-  end
 
-  def get(url, headers = nil)
-    @response = make_request(:get, url, headers: headers)
-  end
+    def post(path, post_body = nil, headers = nil, &block)
+      @response = make_request(:post, path, post_body, headers, &block)
+    end
 
-  def post(url, post_body = nil, headers = nil)
-    @response = make_request(:post, url, body: post_body, headers: headers)
-  end
+    def patch(path, patch_body = nil, headers = nil, &block)
+      @response = make_request(:patch, path, patch_body, headers, &block)
+    end
 
-  def patch(url, patch_body = nil, headers = nil)
-    @response = make_request(:patch, url, body: patch_body, headers: headers)
-  end
+    def put(path, put_body = nil, headers = nil, &block)
+      @response = make_request(:put, path, put_body, headers, &block)
+    end
 
-  def put(url, put_body = nil, headers = nil)
-    @response = make_request(:put, url, body: put_body, headers: headers)
-  end
+    def delete(path, delete_body = nil, headers = nil, &block)
+      @response = make_request(:delete, path, delete_body, headers, &block)
+    end
 
-  def delete(url, delete_body = nil, headers = nil)
-    @response = make_request(:delete, url, body: delete_body, headers: headers)
-  end
+    def head(path, body = nil, headers = nil, &block)
+      @response = make_request(:head, path, body, headers, &block)
+    end
 
-  def head(url, headers = nil)
-    @response = make_request(:head, url, headers: headers)
-  end
+    def options(path, body = nil, headers = nil, &block)
+      @response = make_request(:options, path, body, headers, &block)
+    end
 
-  def options(url, headers = nil)
-    @response = make_request(:options, url, headers: headers)
-  end
+    def response
+      @response
+    end
 
-  def response
-    @response
-  end
+    def headers
+      HashWithIndifferentAccess.new(response.headers)
+    end
 
-  def headers
-    HashWithIndifferentAccess.new(response.headers)
-  end
+    def basic_auth(login, pass)
+      val = Base64.encode64([login, pass].join(':')).gsub!("\n", '')
+      "Basic #{val}"
+    end
 
-  def body
-    response.body
-  end
+    def body
+      response.body
+    end
 
-  def json_body
-    JSON.parse(response.body, symbolize_names: true) rescue fail InvalidJsonError, 'Api request returned invalid json'
-  end
+    def json_body
+      JSON.parse(response.body, symbolize_names: true) rescue fail InvalidJsonError, 'Api request returned invalid json'
+    end
 
-  private
+    private
 
-  def get_url(url)
-    base = Airborne.configuration.base_url || ''
-    base + url
+    def get_url(url)
+      base = Airborne.configuration.base_url || ''
+      base + url
+    end
   end
 end

lib/airborne/faraday_requester.rb

@@ -0,0 +1,35 @@
+require 'faraday'
+
+module Airborne
+  module FaradayRequester
+    def conn
+      @conn ||= Faraday.new do |c|
+                  c.request  :url_encoded
+                  c.adapter Faraday.default_adapter
+                end
+    end
+
+    def make_request(method_name, path, body = {}, headers ={}, &block)
+      conn.send(method_name, path, body) do |req|
+        conn.url_prefix = base_url
+        req.path = path
+        req.headers.merge!(headers)
+        yield req, conn if block_given?
+        req.headers.merge!(conn.headers)
+      end
+    end
+
+    private
+      def base_url
+        Airborne.configuration.base_url
+      end
+  end
+end
+
+module FaradayResponse
+  def code
+    status
+  end
+end
+
+Faraday::Response.send(:include, FaradayResponse)

lib/airborne/rack_test_requester.rb

@@ -2,13 +2,11 @@
 
 module Airborne
   module RackTestRequester
-    def make_request(method, url, options = {})
-      headers = options[:headers] || {}
-      base_headers = Airborne.configuration.headers || {}
-      headers = base_headers.merge(headers)
+    def make_request(method, url, body = {}, headers = {}, &block)
+      headers = (Airborne.configuration.headers || {}).merge(headers || {})
       browser = Rack::Test::Session.new(Rack::MockSession.new(Airborne.configuration.rack_app))
       headers.each { |name, value| browser.header(name, value) }
-      browser.send(method, url, options[:body] || {}, headers)
+      browser.send(method, url, body || {}, headers)
       Rack::MockResponse.class_eval do
         alias_method :code, :status
       end

lib/airborne/rest_client_requester.rb

@@ -2,12 +2,12 @@
 
 module Airborne
   module RestClientRequester
-    def make_request(method, url, options = {})
-      headers = base_headers.merge(options[:headers] || {})
+    def make_request(method, url, body, headers, &block)
+      headers = base_headers.merge(headers || {})
       res = if method == :post || method == :patch || method == :put
         begin
-          request_body = options[:body].nil? ? '' : options[:body]
-          request_body = request_body.to_json if options[:body].is_a?(Hash)
+          request_body = body || ''
+          request_body = request_body.to_json if request_body.is_a?(Hash)
           RestClient.send(method, get_url(url), request_body, headers)
         rescue RestClient::Exception => e
           e.response

lib/airborne/rspec_settings.rb

@@ -0,0 +1,22 @@
+RSpec.configure do |config|
+  config.add_setting :base_url
+  config.add_setting :match_expected_default, default: true
+  config.add_setting :match_actual_default, default: false
+  config.add_setting :match_expected, default: config.match_expected_default
+  config.add_setting :match_actual, default: config.match_actual_default
+  config.add_setting :headers
+  config.add_setting :rack_app
+  config.add_setting :requester_type
+  config.add_setting :requester_module
+  config.add_setting :use_faraday, default: true
+  config.around(:example, match_expected: !config.match_expected_default) do |example|
+    config.match_expected = !config.match_expected_default
+    example.run
+    config.match_expected = config.match_expected_default
+  end
+  config.around(:example, match_actual: !config.match_actual_default) do |example|
+    config.match_actual = !config.match_actual_default
+    example.run
+    config.match_actual = config.match_actual_default
+  end
+end

spec/airborne/base_spec.rb

@@ -52,4 +52,66 @@
     post '/simple_post', {}
     expect(json_body).to_not be(nil)
   end
+
+  context 'when using faraday instead of RestClient' do
+    before do
+      Airborne.configure do |c|
+        c.use_faraday = true
+      end
+    end
+
+    context 'when sucessful request is made' do
+
+      before { mock_get('simple_get') }
+
+      it 'response should be set' do
+        get '/simple_get'
+        expect(response).to_not be(nil)
+      end
+
+      it 'headers should be set' do
+        get '/simple_get'
+        expect(headers).to_not be(nil)
+      end
+
+      it 'headers should be hash with indifferent access' do
+        mock_get('simple_get', 'Content-Type' => 'application/json')
+        get '/simple_get'
+        expect(headers).to be_kind_of(Hash)
+        expect(headers[:content_type]).to eq('application/json')
+        expect(headers['content_type']).to eq('application/json')
+      end
+
+      it 'body should be set' do
+        get '/simple_get'
+        expect(body).to_not be(nil)
+      end
+
+      it 'json body should be symbolized hash' do
+        get '/simple_get'
+        expect(json_body).to be_kind_of(Hash)
+        expect(json_body.first[0]).to be_kind_of(Symbol)
+      end
+    end
+
+    it 'should throw an InvalidJsonError when accessing json_body on invalid json' do
+      mock_get('invalid_json')
+      get '/invalid_json'
+      expect(body).to eq('invalid1234')
+      expect { json_body }.to raise_error(InvalidJsonError)
+    end
+
+    it 'should handle a 500 error on get' do
+      mock_get('simple_get', {}, [500, 'Internal Server Error'])
+      get '/simple_get'
+      expect(json_body).to_not be(nil)
+    end
+
+    it 'should handle a 500 error on post' do
+      mock_post('simple_post', {}, [500, 'Internal Server Error'])
+      post '/simple_post', {}
+      expect(json_body).to_not be(nil)
+    end
+
+  end
 end

spec/airborne/client_requester_spec.rb

@@ -3,11 +3,9 @@
 describe 'client requester' do
   before do
     allow(RestClient).to receive(:send)
-    RSpec::Mocks.space.proxy_for(self).remove_stub_if_present(:get)
   end
 
   after do
-    allow(RestClient).to receive(:send).and_call_original
     Airborne.configure { |config| config.headers =  {} }
   end
 
@@ -19,7 +17,7 @@
   end
 
   it 'should override headers with option[:headers]' do
-    get '/foo', { content_type: 'application/x-www-form-urlencoded' }
+    get '/foo', {} ,{ content_type: 'application/x-www-form-urlencoded' }
 
     expect(RestClient).to have_received(:send)
                             .with(:get, 'http://www.example.com/foo', { content_type: 'application/x-www-form-urlencoded' })