airborne 0.0.21 → 0.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac24980885b43225b94ae50551b7dbc902a530ff
-  data.tar.gz: 3f283170d3c681ba2b951f36c1d3c2be0f007b9f
+  metadata.gz: e009399096d82e3b30b22f4c8f6fc7255e11699f
+  data.tar.gz: 32d38638f1dac42754cc53750ad2a6599be88674
 SHA512:
-  metadata.gz: ef83ca97f295ded5b8c56a46f993cbffe546dc9a21e71cc7892c2fd124b72a09cb524271626f2cdedb6909b67f9489d465f5a3e7743fdc99e5d5e24c65400cf1
-  data.tar.gz: 2b093bcf6f591e4458cae28e59f3d384a58b6df3b8cdefda4e692cc3d1c7b278c0451b9979cc9ee99d303dcfa35a3651a3cffc4d93c472e5473a4e1cfb2df428
+  metadata.gz: 35ac6a72835f11646301b47fbd8ee40134a3f6063e173999866bb4726cadebbd7777194d1aed4a3663b9baa46fdb5c3fff1bc75483b9fa336ae9cc167d2e532f
+  data.tar.gz: 5a574890b43ad0d9e2953055912bbb86ca74c68b7f0b7ceb6e2346ef8e302a59f5b8890ec4c2cd8bc9423ca4af951b97666b0f854262eee6b3e5dfdcf9833e16

data/Gemfile

@@ -7,6 +7,6 @@ gem 'activesupport'
 gem 'coveralls', require: false
 
 group :test do
-	gem 'webmock'
-	gem 'sinatra'
+  gem 'webmock'
+  gem 'sinatra'
 end

data/README.md

@@ -138,32 +138,22 @@ Under the covers, Airborne uses [rack-test](https://github.com/brynary/rack-test
 
 ##Rails Applications
 
-If you're testing and API you've written in Rails, Airborne plays along with `rspec-rails` using the following setup:
+If you're testing an API you've written in Rails, Airborne plays along with `rspec-rails`:
 
-In your `spec/rails_helper.rb` file, change RSpec configure to Airborne configure, and set the `rack_app` configuration setting to your Rails Application:
-
-```ruby
-Airborne.configure do |config|
-  config.rack_app = Rails.application
-end
-```
-
-Then, in your actual tests, since `rspec-rails` already has `get`, `post`, `put`... functions, you need to use `airborne_get`, `airborne_post` instead:
 
 ```ruby
 require 'rails_helper'
 
-RSpec.describe FooController, :type => :controller do
-  describe "GET bar" do
+RSpec.describe HomeController, :type => :controller do
+  describe "GET index" do
     it "returns correct types" do
-      airborne_get '/foo/bar.json'
+      get :index, :format => 'json' #if your route responds to both html and json
       expect_json_types({foo: :string})
     end
   end
 end
 ```
-Just like with all other Rack applications, Airborne uses [rack-test](https://github.com/brynary/rack-test) to make the requests. 
-  
+
 ##API
 
 * `expect_json_types` - Tests the types of the JSON property values returned

data/airborne.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'airborne'
-  s.version     = '0.0.21'
+  s.version     = '0.0.22'
   s.date        = '2014-09-12'
   s.summary = "RSpec driven API testing framework"
   s.authors     = ["Alex Friedman", "Seth Pollack"]

data/lib/airborne.rb

@@ -7,10 +7,10 @@ require 'airborne/base'
 
 
 RSpec.configure do |config|
-	config.include Airborne
-	config.add_setting :base_url
-	config.add_setting :headers
-	config.add_setting :rack_app
-	config.add_setting :requester_type
-	config.add_setting :requester_module
+  config.include Airborne
+  config.add_setting :base_url
+  config.add_setting :headers
+  config.add_setting :rack_app
+  config.add_setting :requester_type
+  config.add_setting :requester_module
 end

data/lib/airborne/base.rb

@@ -2,88 +2,78 @@ require 'json'
 require 'active_support/hash_with_indifferent_access'
 
 module Airborne
-	include RequestExpectations
-
-	def self.configure
-		RSpec.configure do |config|
-			yield config
-		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)
-		end
-	end
-
-	def self.configuration
-		RSpec.configuration
-	end
-
-	def get(url, headers = nil)
-		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}))
-	end
-
-	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}))
-	end
-
-	def delete(url, headers = nil)
-		set_response(make_request(:delete, url, {headers: headers}))
-	end
-
-	def response
-		@response
-	end
-
-	def headers
-		@headers
-	end
-
-	def body
-		@body
-	end
-
-	def json_body
-		@json_body
-	end
-
-	alias_method :airborne_get, :get
-	alias_method :airborne_post, :post
-	alias_method :airborne_patch, :patch
-	alias_method :airborne_put, :put
-	alias_method :airborne_delete, :delete
-	alias_method :airborne_response, :response
-	alias_method :airborne_headers, :headers
-	alias_method :airborne_body, :body
-	alias_method :airborne_json_body, :json_body
-
-	private
-
-	def get_url(url)
-		base = Airborne.configuration.base_url || ""
-		base + url
-	end
-
-	def set_response(res)
-		@response = res
-		@body = res.body
-		@headers = HashWithIndifferentAccess.new(res.headers.deep_symbolize_keys) unless res.headers.nil?
-		begin
-			@json_body = JSON.parse(res.body, symbolize_names: true) unless res.body.empty?
-		rescue
-		end
-	end
+  include RequestExpectations
+
+  def self.configure
+    RSpec.configure do |config|
+      yield config
+    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)
+    end
+  end
+
+  def self.configuration
+    RSpec.configuration
+  end
+
+  def get(url, headers = nil)
+    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}))
+  end
+
+  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}))
+  end
+
+  def delete(url, headers = nil)
+    set_response(make_request(:delete, url, {headers: headers}))
+  end
+
+  def response
+    @response
+  end
+
+  def headers
+    @headers
+  end
+
+  def body
+    @body
+  end
+
+  def json_body
+    @json_body
+  end
+
+  private
+
+  def get_url(url)
+    base = Airborne.configuration.base_url || ""
+    base + url
+  end
+
+  def set_response(res)
+    @response = res
+    @body = res.body
+    @headers = HashWithIndifferentAccess.new(res.headers.deep_symbolize_keys) unless res.headers.nil?
+    begin
+      @json_body = JSON.parse(res.body, symbolize_names: true) unless res.body.empty?
+    rescue
+    end
+  end
 end

data/lib/airborne/optional_hash_type_expectations.rb

@@ -1,15 +1,15 @@
 module Airborne
-	class OptionalHashTypeExpectations
-		include Enumerable
-		attr_accessor :hash
-		def initialize(hash)
-			@hash = hash
-		end
+  class OptionalHashTypeExpectations
+    include Enumerable
+    attr_accessor :hash
+    def initialize(hash)
+      @hash = hash
+    end
 
-		def each
-			@hash.each do|k,v|
-				yield(k,v)
-			end
-		end
-	end
+    def each
+      @hash.each do|k,v|
+        yield(k,v)
+      end
+    end
+  end
 end

data/lib/airborne/path_matcher.rb

@@ -1,45 +1,45 @@
 module Airborne
-	module PathMatcher
-		def get_by_path(path, json, &block)
-			type = false
-			parts = path.split('.')
-			parts.each_with_index do |part, index|
-				if part == '*' || part == '?'
-					type = part
-					raise "Expected #{path} to be array got #{json.class} from JSON response" unless json.class == Array
-					if index < parts.length.pred
-						json.each do |element|
-							sub_path = parts[(index.next)...(parts.length)].join('.')
-							get_by_path(sub_path, element, &block)
-						end
-						return
-					end
-					next
-				end
-				if /^[\d]+(\.[\d]+){0,1}$/ === part
-					part = part.to_i
-					json = json[part]
-				else
-					json = json[part.to_sym]
-					raise "Expected #{path} to be object or array got #{json.class} from JSON response" unless [Array, Hash, NilClass].include?(json.class)
-				end
-			end
-			if type == '*'
-				json.each{|part| yield part}
-			elsif type == '?'
-				item_count = json.length
-				error_count = 0
-				json.each do |part|
-					begin
-						yield part
-					rescue Exception => e
-						error_count += 1
-						raise "Expected one object in path #{path} to match provided JSON values" if item_count == error_count
-					end
-				end
-			else
-				yield json
-			end
-		end
-	end
+  module PathMatcher
+    def get_by_path(path, json, &block)
+      type = false
+      parts = path.split('.')
+      parts.each_with_index do |part, index|
+        if part == '*' || part == '?'
+          type = part
+          raise "Expected #{path} to be array got #{json.class} from JSON response" unless json.class == Array
+          if index < parts.length.pred
+            json.each do |element|
+              sub_path = parts[(index.next)...(parts.length)].join('.')
+              get_by_path(sub_path, element, &block)
+            end
+            return
+          end
+          next
+        end
+        if /^[\d]+(\.[\d]+){0,1}$/ === part
+          part = part.to_i
+          json = json[part]
+        else
+          json = json[part.to_sym]
+          raise "Expected #{path} to be object or array got #{json.class} from JSON response" unless [Array, Hash, NilClass].include?(json.class)
+        end
+      end
+      if type == '*'
+        json.each{|part| yield part}
+      elsif type == '?'
+        item_count = json.length
+        error_count = 0
+        json.each do |part|
+          begin
+            yield part
+          rescue Exception => e
+            error_count += 1
+            raise "Expected one object in path #{path} to match provided JSON values" if item_count == error_count
+          end
+        end
+      else
+        yield json
+      end
+    end
+  end
 end

data/lib/airborne/rack_test_requester.rb

@@ -1,11 +1,11 @@
 require 'rack/test'
 
 module Airborne
-	module RackTestRequester
-		def make_request(method, url, options = {})
-			browser = Rack::Test::Session.new(Rack::MockSession.new(Airborne.configuration.rack_app))
-			browser.send(method, url, options[:body] || {}, options[:headers] || {})
-			browser.last_response
-		end
-	end
+  module RackTestRequester
+    def make_request(method, url, options = {})
+      browser = Rack::Test::Session.new(Rack::MockSession.new(Airborne.configuration.rack_app))
+      browser.send(method, url, options[:body] || {}, options[:headers] || {})
+      browser.last_response
+    end
+  end
 end

data/lib/airborne/request_expectations.rb

@@ -1,130 +1,136 @@
 require 'rspec'
 
 module Airborne
-	module RequestExpectations
-		include RSpec
-		include PathMatcher
+  module RequestExpectations
+    include RSpec
+    include PathMatcher
 
-		def expect_json_types(*args)
-			call_with_path(args) do |param, body|
-				expect_json_types_impl(param, body)
-			end
-		end
+    def expect_json_types(*args)
+      set_response(@response) if @json_body.nil?
+      call_with_path(args) do |param, body|
+        expect_json_types_impl(param, body)
+      end
+    end
 
-		def expect_json(*args)
-			call_with_path(args) do |param, body|
-				expect_json_impl(param, body)
-			end
-		end
+    def expect_json(*args)
+      set_response(@response) if @json_body.nil?
+      call_with_path(args) do |param, body|
+        expect_json_impl(param, body)
+      end
+    end
 
-		def expect_json_keys(*args)
-			call_with_path(args) do |param, body|
-				expect(body.keys).to include(*param)
-			end
-		end
+    def expect_json_keys(*args)
+      set_response(@response) if @json_body.nil?
+      call_with_path(args) do |param, body|
+        expect(body.keys).to include(*param)
+      end
+    end
 
-		def expect_status(code)
-			expect(response.code).to eq(code)
-		end
+    def expect_status(code)
+      set_response(@response) if @json_body.nil?
+      expect(response.code).to eq(code)
+    end
 
-		def expect_header(key, content)
-			header = headers[key]
-			if header
-				expect(header.downcase).to eq(content.downcase)
-			else
-				raise "Header #{key} not present in HTTP response"
-			end
-		end
+    def expect_header(key, content)
+      set_response(@response) if @json_body.nil?
+      header = headers[key]
+      if header
+        expect(header.downcase).to eq(content.downcase)
+      else
+        raise "Header #{key} not present in HTTP response"
+      end
+    end
 
-		def expect_header_contains(key, content)
-			header = headers[key]
-			if header
-				expect(header.downcase).to include(content.downcase)
-			else
-				raise "Header #{key} not present in HTTP response"
-			end
-		end
+    def expect_header_contains(key, content)
+      set_response(@response) if @json_body.nil?
+      header = headers[key]
+      if header
+        expect(header.downcase).to include(content.downcase)
+      else
+        raise "Header #{key} not present in HTTP response"
+      end
+    end
 
-		def optional(hash)
-			OptionalHashTypeExpectations.new(hash)
-		end
+    def optional(hash)
+      OptionalHashTypeExpectations.new(hash)
+    end
 
-		def regex(reg)
-			Regexp.new(reg)
-		end
+    def regex(reg)
+      Regexp.new(reg)
+    end
 
-		private
+    private
 
-		def call_with_path(args)
-			if args.length == 2
-				get_by_path(args[0], json_body) do|json_chunk|
-					yield(args[1], json_chunk)
-				end
-			else
-				yield(args[0], json_body)
-			end
-		end
+    def call_with_path(args)
+      if args.length == 2
+        get_by_path(args[0], json_body) do|json_chunk|
+          yield(args[1], json_chunk)
+        end
+      else
+        yield(args[0], json_body)
+      end
+    end
 
-		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],
-				string: [String],
-				array_of_strings: [String],
-				boolean: [TrueClass, FalseClass],
-				array_of_booleans: [TrueClass, FalseClass],
-				bool: [TrueClass, FalseClass],
-				array_of_bools: [TrueClass, FalseClass],
-				object: [Hash],
-				array_of_objects: [Hash],
-				array: [Array],
-				array_of_arrays: [Array]
-			}
+    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],
+        string: [String],
+        array_of_strings: [String],
+        boolean: [TrueClass, FalseClass],
+        array_of_booleans: [TrueClass, FalseClass],
+        bool: [TrueClass, FalseClass],
+        array_of_bools: [TrueClass, FalseClass],
+        object: [Hash],
+        array_of_objects: [Hash],
+        array: [Array],
+        array_of_arrays: [Array]
+      }
 
-			mapper = base_mapper.clone
-			base_mapper.each do |key, value|
-				mapper[(key.to_s + "_or_null").to_sym] = value + [NilClass]
-			end
-			mapper
-		end
+      mapper = base_mapper.clone
+      base_mapper.each do |key, value|
+        mapper[(key.to_s + "_or_null").to_sym] = value + [NilClass]
+      end
+      mapper
+    end
 
-		def expect_json_types_impl(expectations, hash)
-			return if expectations.class == Airborne::OptionalHashTypeExpectations && hash.nil?
-			@mapper ||= get_mapper
-			expectations.each do |prop_name, expected_type|
-				value = hash[prop_name]
-				if expected_type.class == Hash || expected_type.class ==  Airborne::OptionalHashTypeExpectations
-					expect_json_types_impl(expected_type, value)
-				elsif expected_type.class == Proc
-					expected_type.call(value)
-				elsif expected_type.to_s.include?("array_of")
-					expect(value.class).to eq(Array), "Expected #{prop_name} to be of type #{expected_type}, got #{value.class} instead"
-					value.each do |val|
-						expect(@mapper[expected_type].include?(val.class)).to eq(true), "Expected #{prop_name} to be of type #{expected_type}, got #{val.class} instead"	
-					end
-				else
-					expect(@mapper[expected_type].include?(value.class)).to eq(true), "Expected #{prop_name} to be of type #{expected_type}, got #{value.class} instead"
-				end
-			end
-		end
+    def expect_json_types_impl(expectations, hash)
+      return if expectations.class == Airborne::OptionalHashTypeExpectations && hash.nil?
+      @mapper ||= get_mapper
+      expectations.each do |prop_name, expected_type|
+        value = hash[prop_name]
+        if expected_type.class == Hash || expected_type.class ==  Airborne::OptionalHashTypeExpectations
+          expect_json_types_impl(expected_type, value)
+        elsif expected_type.class == Proc
+          expected_type.call(value)
+        elsif expected_type.to_s.include?("array_of")
+          expect(value.class).to eq(Array), "Expected #{prop_name} to be of type #{expected_type}, got #{value.class} instead"
+          value.each do |val|
+            expect(@mapper[expected_type].include?(val.class)).to eq(true), "Expected #{prop_name} to be of type #{expected_type}, got #{val.class} instead"  
+          end
+        else
+          expect(@mapper[expected_type].include?(value.class)).to eq(true), "Expected #{prop_name} to be of type #{expected_type}, got #{value.class} instead"
+        end
+      end
+    end
 
-		def expect_json_impl(expectations, hash)
-			expectations.each do |prop_name, expected_value|
-				actual_value = hash[prop_name]
-				if expected_value.class == Hash
-					expect_json_impl(expected_value, actual_value)
-				elsif expected_value.class == Proc
-					expected_value.call(actual_value)
-				elsif expected_value.class == Regexp
-					expect(actual_value).to match(expected_value)
-				else
-					expect(actual_value).to eq(expected_value)
-				end
-			end
-		end
-	end
+    def expect_json_impl(expectations, hash)
+      expectations.each do |prop_name, expected_value|
+        actual_value = hash[prop_name]
+        if expected_value.class == Hash
+          expect_json_impl(expected_value, actual_value)
+        elsif expected_value.class == Proc
+          expected_value.call(actual_value)
+        elsif expected_value.class == Regexp
+          expect(actual_value).to match(expected_value)
+        else
+          expect(actual_value).to eq(expected_value)
+        end
+      end
+    end
+  end
 end