airborne 0.1.15 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ce172c348689ccc6d7d3df32523db62d7671a1e
-  data.tar.gz: ec99365c4dcc0920dcd02197f47e2bb6dd985999
+  metadata.gz: ac06c0189febbd0649871cf9919a66e2d8cf2c82
+  data.tar.gz: ab35b7f94d89caabcdb9936f7f8ac9172c872b59
 SHA512:
-  metadata.gz: 90c1a8944f16fb51139cf02d0e3bf29e30217ce9e6bf8d25116fc9cc221e1812426bef30d55cbf475ef476375f8b9393ea86c801cd81a0a588ea046d79cf4e36
-  data.tar.gz: d141eaa4f1917c759e0c1e7ea7665fe07085f4c375737ae2d3286e570d2a59c2647482f3a52004c775617635f859fd0ae88d0e097e4692ca555565dd4e2cfe06
+  metadata.gz: dd8d1a0d1b65801745f20d9a044341c884d00c5391290c4f5db2da9544d006722a247e0cb1edeb2ed9f3d33f4d29ab5a8d17bf8b77c11af4f4d3834cf596c4b4
+  data.tar.gz: 94615d3ca58942930f91208d83c7740184631bbb5bbd44dc5db12582f2ce68ec49684103dab23e44ecae30fe002a793b4ca75eddd73aa8d13d053f7232526c57

data/README.md

@@ -137,6 +137,12 @@ For requests that require a body (`post`, `put`, `patch`) you can pass the body
 post 'http://example.com/api/v1/my_api', {:name => 'John Doe'}, {'x-auth-token' => 'my_token'}
 ```
 
+For requests that require Query params you can pass a params hash into headers.
+
+```ruby
+post 'http://example.com/api/v1/my_api', {}, {'params' => {'param_key' => 'param_value'}
+```
+
 ##Testing Rack Applications
 
 If you have an existing Rack application like `sinatra` or `grape` you can run Airborne against your application and test without actually having a server running. To do that, just specify your rack application in your Airborne configuration:

data/airborne.gemspec

@@ -1,15 +1,15 @@
 Gem::Specification.new do |s|
   s.name        = 'airborne'
-  s.version     = '0.1.15'
+  s.version     = '0.1.16'
   s.date        = '2015-03-03'
-  s.summary = "RSpec driven API testing framework"
-  s.authors     = ["Alex Friedman", "Seth Pollack"]
+  s.summary = 'RSpec driven API testing framework'
+  s.authors     = ['Alex Friedman', 'Seth Pollack']
   s.email       = ['a.friedman07@gmail.com', 'teampollack@gmail.com']
   s.require_paths = ['lib']
   s.files = `git ls-files`.split("\n")
   s.license     = 'MIT'
   s.add_runtime_dependency 'rspec', '~> 3.1', '>= 3.1.0'
-  s.add_runtime_dependency 'rest-client', '~> 1.7', '>= 1.7.3' #version 1.7.3 fixes security vulnerability https://github.com/brooklynDev/airborne/issues/41
+  s.add_runtime_dependency 'rest-client', '~> 1.7', '>= 1.7.3' # version 1.7.3 fixes security vulnerability https://github.com/brooklynDev/airborne/issues/41
   s.add_runtime_dependency 'rack-test', '~> 0.6', '>= 0.6.2'
   s.add_runtime_dependency 'activesupport', '>= 3.0.0', '>= 3.0.0'
   s.add_development_dependency 'webmock', '~> 0'

data/lib/airborne.rb

@@ -5,7 +5,6 @@ require 'airborne/rest_client_requester'
 require 'airborne/rack_test_requester'
 require 'airborne/base'
 
-
 RSpec.configure do |config|
   config.include Airborne
   config.add_setting :base_url
@@ -13,4 +12,4 @@ RSpec.configure do |config|
   config.add_setting :rack_app
   config.add_setting :requester_type
   config.add_setting :requester_module
-end
+end

data/lib/airborne/base.rb

@@ -1,9 +1,14 @@
 require 'json'
-require 'active_support/hash_with_indifferent_access'
+require 'active_support'
+require 'active_support/core_ext/hash/indifferent_access'
 
 module Airborne
   class InvalidJsonError < StandardError; end
+
   include RequestExpectations
+
+  attr_reader :response, :headers, :body
+
   def self.configure
     RSpec.configure do |config|
       yield config
@@ -11,9 +16,9 @@ module Airborne
   end
 
   def self.included(base)
-    if(!Airborne.configuration.requester_module.nil?)
+    if !Airborne.configuration.requester_module.nil?
       base.send(:include, Airborne.configuration.requester_module)
-    elsif(!Airborne.configuration.rack_app.nil?)
+    elsif !Airborne.configuration.rack_app.nil?
       base.send(:include, RackTestRequester)
     else
       base.send(:include, RestClientRequester)
@@ -25,54 +30,43 @@ module Airborne
   end
 
   def get(url, headers = nil)
-    set_response(make_request(:get, url, {headers: headers}))
+    set_response(make_request(:get, url, headers: headers))
   end
 
   def post(url, post_body = nil, headers = nil)
-    set_response(make_request(:post, url, {body: post_body, headers: headers}))
+    set_response(make_request(:post, url, body: post_body, headers: headers))
   end
 
-  def patch(url, patch_body = nil, headers = nil )
-    set_response(make_request(:patch, url, {body: patch_body, headers: headers}))
+  def patch(url, patch_body = nil, headers = nil)
+    set_response(make_request(:patch, url, body: patch_body, headers: headers))
   end
 
-  def put(url, put_body = nil, headers = nil )
-    set_response(make_request(:put, url, {body: put_body, headers: headers}))
+  def put(url, put_body = nil, headers = nil)
+    set_response(make_request(:put, url, body: put_body, headers: headers))
   end
 
   def delete(url, headers = nil)
-    set_response(make_request(:delete, url, {headers: headers}))
+    set_response(make_request(:delete, url, headers: headers))
   end
 
   def head(url, headers = nil)
-    set_response(make_request(:head, url, {headers: headers}))
+    set_response(make_request(:head, url, headers: headers))
   end
 
   def options(url, headers = nil)
-    set_response(make_request(:options, url, {headers: headers}))
-  end
-
-  def response
-    @response
-  end
-
-  def headers
-    @headers
-  end
-
-  def body
-    @body
+    set_response(make_request(:options, url, headers: headers))
   end
 
   def json_body
-    raise InvalidJsonError, "Api request returned invalid json" unless @json_body
+    set_response(@response) if @json_body.nil? && !@response.nil?
+    fail InvalidJsonError, 'Api request returned invalid json' unless @json_body
     @json_body
   end
 
   private
 
   def get_url(url)
-    base = Airborne.configuration.base_url || ""
+    base = Airborne.configuration.base_url || ''
     base + url
   end
 

data/lib/airborne/optional_hash_type_expectations.rb

@@ -7,9 +7,9 @@ module Airborne
     end
 
     def each
-      @hash.each do|k,v|
-        yield(k,v)
+      @hash.each do|k, v|
+        yield(k, v)
       end
     end
   end
-end
+end

data/lib/airborne/path_matcher.rb

@@ -1,9 +1,9 @@
 module Airborne
   class PathError < StandardError; end
-  module PathMatcher
 
+  module PathMatcher
     def get_by_path(path, json, &block)
-      raise PathError, "Invalid Path, contains '..'" if /\.\./ =~ path
+      fail PathError, "Invalid Path, contains '..'" if /\.\./ =~ path
       type = false
       parts = path.split('.')
       parts.each_with_index do |part, index|
@@ -11,15 +11,14 @@ module Airborne
           ensure_array(path, json)
           type = part
           if index < parts.length.pred
-            walk_with_path(type, index, path, parts, json, &block)
-            return
+            walk_with_path(type, index, path, parts, json, &block) && return
           end
           next
         end
         begin
           json = process_json(part, json)
         rescue
-          raise PathError, "Expected #{json.class}\nto to be an object with property #{part}"
+          raise PathError, "Expected #{json.class}\nto be an object with property #{part}"
         end
       end
       if type == '*'
@@ -51,7 +50,7 @@ module Airborne
     end
 
     def process_json(part, json)
-      if is_index?(part) && json.is_a?(Array)
+      if index?(part) && json.is_a?(Array)
         part = part.to_i
         json = json[part]
       else
@@ -60,7 +59,7 @@ module Airborne
       json
     end
 
-    def is_index?(part)
+    def index?(part)
       part =~ /^\d+$/
     end
 
@@ -80,7 +79,7 @@ module Airborne
     def expect_all(json, &block)
       last_error = nil
       begin
-        json.each{|part| yield part}
+        json.each { |part| yield part }
       rescue Exception => e
         last_error = e
       end
@@ -88,16 +87,15 @@ module Airborne
     end
 
     def ensure_match_one(path, item_count, error_count)
-      raise RSpec::Expectations::ExpectationNotMetError, "Expected one object in path #{path} to match provided JSON values" if item_count == error_count
+      fail RSpec::Expectations::ExpectationNotMetError, "Expected one object in path #{path} to match provided JSON values" if item_count == error_count
     end
 
     def ensure_match_all(error)
-      raise error unless error.nil?
+      fail error unless error.nil?
     end
 
     def ensure_array(path, json)
-      raise RSpec::Expectations::ExpectationNotMetError, "Expected #{path} to be array got #{json.class} from JSON response" unless json.class == Array
+      fail RSpec::Expectations::ExpectationNotMetError, "Expected #{path} to be array got #{json.class} from JSON response" unless json.class == Array
     end
-
   end
 end

data/lib/airborne/rack_test_requester.rb

@@ -7,6 +7,7 @@ module Airborne
       base_headers = Airborne.configuration.headers || {}
       headers = base_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)
       Rack::MockResponse.class_eval do
         alias_method :code, :status

data/lib/airborne/request_expectations.rb

@@ -53,14 +53,14 @@ module Airborne
     end
 
     def date
-      lambda {|value| yield DateTime.parse(value)}
+      -> (value) { yield DateTime.parse(value) }
     end
 
     [:expect_json_types, :expect_json, :expect_json_keys, :expect_status, :expect_header, :expect_header_contains].each do |method_name|
       method = instance_method(method_name)
       define_method(method_name) do |*args, &block|
         set_rails_response
-        method.bind(self).(*args, &block)
+        method.bind(self).call(*args, &block)
       end
     end
 
@@ -75,7 +75,7 @@ module Airborne
           expect(header.downcase).to eq(content.downcase)
         end
       else
-        raise RSpec::Expectations::ExpectationNotMetError, "Header #{key} not present in HTTP response"
+        fail RSpec::Expectations::ExpectationNotMetError, "Header #{key} not present in HTTP response"
       end
     end
 
@@ -95,12 +95,12 @@ module Airborne
 
     def get_mapper
       base_mapper = {
-        integer: [Fixnum,Bignum],
-        array_of_integers: [Fixnum,Bignum],
-        int: [Fixnum,Bignum],
-        array_of_ints: [Fixnum,Bignum],
-        float: [Float,Fixnum,Bignum],
-        array_of_floats: [Float,Fixnum,Bignum],
+        integer: [Fixnum, Bignum],
+        array_of_integers: [Fixnum, Bignum],
+        int: [Fixnum, Bignum],
+        array_of_ints: [Fixnum, Bignum],
+        float: [Float, Fixnum, Bignum],
+        array_of_floats: [Float, Fixnum, Bignum],
         string: [String],
         array_of_strings: [String],
         boolean: [TrueClass, FalseClass],
@@ -111,18 +111,19 @@ module Airborne
         array_of_objects: [Hash],
         array: [Array],
         array_of_arrays: [Array],
-        date: [DateTime]
+        date: [DateTime],
+        null: [NilClass]
       }
 
       mapper = base_mapper.clone
       base_mapper.each do |key, value|
-        mapper[(key.to_s + "_or_null").to_sym] = value + [NilClass]
+        mapper[(key.to_s + '_or_null').to_sym] = value + [NilClass]
       end
       mapper
     end
 
     def expect_json_types_impl(expectations, hash_or_value)
-      return if is_nil_optional_hash?(expectations, hash_or_value)
+      return if nil_optional_hash?(expectations, hash_or_value)
 
       @mapper ||= get_mapper
 
@@ -138,10 +139,10 @@ module Airborne
         expected_class = expected_type.class
         value_class = value.class
 
-        next expect_json_types_impl(expected_type, value) if is_hash?(expected_class)
+        next expect_json_types_impl(expected_type, value) if hash?(expected_class)
         next expected_type.call(value) if expected_class == Proc
 
-        if expected_type.to_s.include?("array_of")
+        if expected_type.to_s.include?('array_of')
           check_array_types(value, value_class, prop_name, expected_type)
         else
           expect_type(expected_type, value_class, prop_name)
@@ -151,7 +152,7 @@ module Airborne
 
     def convert_to_date(value)
       begin
-        value = DateTime.parse(value)
+        DateTime.parse(value)
       rescue
       end
     end
@@ -163,18 +164,19 @@ module Airborne
       end
     end
 
-    def is_nil_optional_hash?(expectations, hash)
+    def nil_optional_hash?(expectations, hash)
       expectations.class == Airborne::OptionalHashTypeExpectations && hash.nil?
     end
 
     def expect_type(expected_type, value_class, prop_name = nil)
-      insert = prop_name.nil? ? "" : "#{prop_name} to be of type"
+      insert = prop_name.nil? ? '' : "#{prop_name} to be of type"
       msg = "Expected #{insert} #{expected_type}\n got #{value_class} instead"
+      fail ExpectationError, "Expected type #{expected_type}\nis an invalid type" if @mapper[expected_type].nil?
       expect(@mapper[expected_type].include?(value_class)).to eq(true), msg
     end
 
-    def is_hash?(expected_class)
-      expected_class == Hash || expected_class ==  Airborne::OptionalHashTypeExpectations
+    def hash?(expected_class)
+      expected_class == Hash || expected_class == Airborne::OptionalHashTypeExpectations
     end
 
     def expect_array(value_class, prop_name, expected_type)
@@ -183,11 +185,11 @@ module Airborne
 
     def expect_json_impl(expectations, hash)
       hash = hash.to_s if expectations.class == Regexp
-      return expect(hash).to match(expectations) if is_property?(expectations)
+      return expect(hash).to match(expectations) if property?(expectations)
       expectations.each do |prop_name, expected_value|
-        actual_value = ensure_hash_contains_prop(prop_name, hash) {hash[prop_name]}
+        actual_value = ensure_hash_contains_prop(prop_name, hash) { hash[prop_name] }
         expected_class = expected_value.class
-        next expect_json_impl(expected_value, actual_value) if expected_class == Hash
+        next expect(actual_value).to match(expected_value) if expected_class == Hash
         next expected_value.call(actual_value) if expected_class == Proc
         next expect(actual_value.to_s).to match(expected_value) if expected_class == Regexp
         expect(actual_value).to eq(expected_value)
@@ -221,19 +223,12 @@ module Airborne
       ->(data) { expect(data.size).to eq(expected_size) }
     end
 
-    def is_property?(expectations)
+    def property?(expectations)
       [String, Regexp, Float, Fixnum, Bignum, TrueClass, FalseClass, NilClass].include?(expectations.class)
     end
 
-    # Resolve a supplied status to the appropriate class for the returned
-    # status being tested. This helps reduce brittleness due to '200' != 200
-    # when for the purposes of testing a response it is the same thing.
-    #
-    # @param candidate
-    # @param authority
-    # @return [String]
     def resolve_status(candidate, authority)
-      candidate = Rack::Utils::SYMBOL_TO_STATUS_CODE[candidate] if candidate.kind_of?(Symbol)
+      candidate = Rack::Utils::SYMBOL_TO_STATUS_CODE[candidate] if candidate.is_a?(Symbol)
       case authority
       when String then candidate.to_s
       when Fixnum then candidate.to_i

data/lib/airborne/rest_client_requester.rb

@@ -3,26 +3,25 @@ require 'rest_client'
 module Airborne
   module RestClientRequester
     def make_request(method, url, options = {})
-      headers = {content_type: :json}.merge(options[:headers] || {})
+      headers = { content_type: :json }.merge(options[:headers] || {})
       base_headers = Airborne.configuration.headers || {}
       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)
-          RestClient.send(method, get_url(url), request_body, headers)
-        rescue RestClient::Exception => e
-          e.response
-        end
-      else
-        begin
-          RestClient.send(method, get_url(url), headers)
-        rescue RestClient::Exception => e
-          e.response
-        end
-
-      end
+              begin
+                request_body = options[:body].nil? ? '' : options[:body]
+                request_body = request_body.to_json if options[:body].is_a?(Hash)
+                RestClient.send(method, get_url(url), request_body, headers)
+              rescue RestClient::Exception => e
+                e.response
+              end
+            else
+              begin
+                RestClient.send(method, get_url(url), headers)
+              rescue RestClient::Exception => e
+                e.response
+              end
+            end
       res
     end
   end
-end
+end

data/spec/airborne/base_spec.rb

@@ -10,46 +10,46 @@ describe 'base spec' do
   it 'when request is made headers should be set' do
     mock_get('simple_get')
     get '/simple_get'
-    expect(headers).to_not be(nil)    
+    expect(headers).to_not be(nil)
   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("1234")
-    expect{json_body}.to raise_error
+    expect(body).to eq('1234')
+    expect { json_body }.to raise_error
   end
 
   it 'when request is made headers should be hash with indifferent access' do
-    mock_get('simple_get', {'Content-Type' => 'application/json'})
+    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 
+  end
 
   it 'when request is made body should be set' do
     mock_get('simple_get')
     get '/simple_get'
-    expect(body).to_not be(nil)   
+    expect(body).to_not be(nil)
   end
 
   it 'when request is made json body should be symbolized hash' do
     mock_get('simple_get')
     get '/simple_get'
     expect(json_body).to be_kind_of(Hash)
-    expect(json_body.first[0]).to be_kind_of(Symbol)    
+    expect(json_body.first[0]).to be_kind_of(Symbol)
   end
 
   it 'should handle a 500 error on get' do
-    mock_get('simple_get', {}, [500, "Internal Server Error"])
+    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"])
+    mock_post('simple_post', {}, [500, 'Internal Server Error'])
     post '/simple_post', {}
     expect(json_body).to_not be(nil)
   end
-end
+end