airborne 0.1.20 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75e39a27825d4bd6356a68d61d5298b9df7efc78
-  data.tar.gz: a092d5c4e6ea8a77e5ffd44507bd30809fc1d918
+  metadata.gz: 7a65123aada9fd5ec28e73e1dd39a55b85b4c120
+  data.tar.gz: df26ba37c5fa926a1c748c4c6e7b441946da49c8
 SHA512:
-  metadata.gz: 07884c5bf421f27b6c1e5f6b24d90468b2148b6cff688bd36569445259f200311d95b3ca17118af96a96458f7ef2c04462b5e3aa9efee854036fb08832bd7622
-  data.tar.gz: c358814cc80983f0895eca497b37602f8123ea300f7ff8814d1559fc8cf7e7f2c99adc2c1dc9af5b94e4e114341ff07de11a43f0edd01e331ed14069cfc3b518
+  metadata.gz: ac97899e3eb391a2df1f4590b7a8102f7eb40d97fbe4c363ae53ee36e75e5e48ea970780e68e008f8e2af2dde2fa64181c4592128fc49d9845dc30a73125b36b
+  data.tar.gz: 166a72d89beb9dfaa523c5ca402f4b0ca8235f696b523773bf43c381cff4b368fda5eedcb9c9b8ce7888fede5117d5e5674ead901508ce855c87d17ee0b3b249

data/.travis.yml

@@ -3,7 +3,8 @@ language: ruby
 rvm:
   - 2.0.0
   - 2.1.0
-  - 2.1.3
+  - 2.1.7
+  - 2.2.3
 
 
 script: bundle exec rspec spec

data/README.md

@@ -12,13 +12,13 @@ RSpec driven API testing framework
 ## Installation
 
 Install Airborne:
-
-    gem install airborne
-
+```shell
+$ gem install airborne
+```
 Or add it to your Gemfile:
-
-    gem 'airborne'
-
+```shell
+$ gem 'airborne'
+```
 ##Creating Tests
 
 ```ruby
@@ -357,10 +357,39 @@ describe 'spec' do
 end
 ```
 
+You can also control the strictness of `expect_json` and `expect_json_types` with the global settings `match_expected_default` and `match_actual_default` like this.
+
+```ruby
+Airborne.configure do |config|
+  config.match_expected_default = true
+  config.match_actual_default = false
+end
+```
+
+Airborne sets `match_expected_default` to `true` and `match_actual_default` to `false` by default.
+
+You can use the `match_expected` and `match_actual` settings to override your global defaults in test blocks like this.
+
+```ruby
+describe 'test something', match_expected: true, match_actual: false do
+end
+```
+
+OR
+
+```ruby
+describe 'test something' do
+  Airborne.configuration.match_expected = true
+  Airborne.configuration.match_actual = false
+end
+```
+
 ## Run it from the CLI
 
-    $ cd your/project
-    $ rspec spec
+```shell
+$ cd your/project
+$ rspec spec
+```
 ## Authors
 * [Seth Pollack](https://github.com/sethpollack)
 * [Alex Friedman](https://github.com/brooklynDev)

data/airborne.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'airborne'
-  s.version     = '0.1.20'
+  s.version     = '0.2.0'
   s.date        = Date.today.to_s
   s.summary = 'RSpec driven API testing framework'
   s.authors     = ['Alex Friedman', 'Seth Pollack']

data/lib/airborne.rb

@@ -8,8 +8,18 @@ require 'airborne/base'
 RSpec.configure do |config|
   config.include Airborne
   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]
+  end
 end

data/lib/airborne/optional_hash_type_expectations.rb

@@ -11,5 +11,13 @@ module Airborne
         yield(k, v)
       end
     end
+
+    def [](val)
+      @hash[val]
+    end
+
+    def keys
+      @hash.keys
+    end
   end
 end

data/lib/airborne/request_expectations.rb

@@ -67,77 +67,105 @@ module Airborne
           expect(header.downcase).to eq(content.downcase)
         end
       else
-        fail RSpec::Expectations::ExpectationNotMetError, "Header #{key} not present in HTTP response"
+        fail RSpec::Expectations::ExpectationNotMetError, "Header #{key} not present in the HTTP response"
       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 expect_json_impl(expected, actual)
+      return if nil_optional_hash?(expected, actual)
 
-    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],
-        date: [DateTime],
-        null: [NilClass]
-      }
+      actual = actual.to_s if expected.class == Regexp
 
-      mapper = base_mapper.clone
-      base_mapper.each do |key, value|
-        mapper[(key.to_s + '_or_null').to_sym] = value + [NilClass]
+      return expect(actual).to match(expected) if property?(expected)
+
+      keys = []
+
+      keys << expected.keys if match_expected?
+      keys << actual.keys if match_actual?
+      keys = expected.keys & actual.keys if match_none?
+
+      keys.flatten.uniq.each do |prop|
+        expected_value  = extract_expected(expected, prop)
+        actual_value    = extract_actual(actual, prop)
+
+        next expect_json_impl(expected_value, actual_value) if hash?(expected_value)
+        next expected_value.call(actual_value) if expected_value.is_a?(Proc)
+        next expect(actual_value.to_s).to match(expected_value) if expected_value.is_a?(Regexp)
+
+        expect(actual_value).to eq(expected_value)
       end
-      mapper
     end
 
-    def expect_json_types_impl(expectations, hash_or_value)
-      return if nil_optional_hash?(expectations, hash_or_value)
+    def expect_json_types_impl(expected, actual)
+      return if nil_optional_hash?(expected, actual)
 
       @mapper ||= get_mapper
 
-      hash_or_value = convert_to_date(hash_or_value) if expectations == :date
+      actual = convert_to_date(actual) if expected == :date
 
-      return expect_type(expectations, hash_or_value.class) if expectations.class == Symbol
-      return expectations.call(hash_or_value) if expectations.class == Proc
+      return expect_type(expected, actual.class) if expected.is_a?(Symbol)
+      return expected.call(actual) if expected.is_a?(Proc)
 
-      expectations.each do |prop_name, expected_type|
-        value =  ensure_hash_contains_prop(prop_name, hash_or_value) do
-          expected_type == :date ? convert_to_date(hash_or_value[prop_name]) : hash_or_value[prop_name]
-        end
-        expected_class = expected_type.class
-        value_class = value.class
+      keys = []
+
+      keys << expected.keys if match_expected?
+      keys << actual.keys if match_actual?
+      keys = expected.keys & actual.keys if match_none?
 
-        next expect_json_types_impl(expected_type, value) if hash?(expected_class)
-        next expected_type.call(value) if expected_class == Proc
+      keys.flatten.uniq.each do |prop|
+        type  = extract_expected(expected, prop)
+        value = extract_actual(actual, prop)
+        value = convert_to_date(value) if type == :date
 
-        if expected_type.to_s.include?('array_of')
-          check_array_types(value, value_class, prop_name, expected_type)
+        next expect_json_types_impl(type, value) if hash?(type)
+        next type.call(value) if type.is_a?(Proc)
+
+        val_class = value.class
+
+        if type.to_s.include?('array_of')
+          check_array_types(value, val_class, prop, type)
         else
-          expect_type(expected_type, value_class, prop_name)
+          expect_type(type, val_class, prop)
+        end
+      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 extract_expected(expected, prop)
+      begin
+        type = expected[prop]
+        type.nil? ? raise : type
+      rescue
+        raise ExpectationError, "Expectation is expected to contain property: #{prop}"
       end
     end
 
+    def extract_actual(actual, prop)
+      begin
+        value = actual[prop]
+      rescue
+        raise ExpectationError, "Expected #{actual.class} #{actual}\nto be an object with property #{prop}"
+      end
+    end
+
+    def expect_type(expected_type, value_class, prop_name = nil)
+      fail ExpectationError, "Expected type #{expected_type}\nis an invalid type" if @mapper[expected_type].nil?
+
+      insert = prop_name.nil? ? '' : "#{prop_name} to be of type"
+      message = "Expected #{insert} #{expected_type}\n got #{value_class} instead"
+
+      expect(@mapper[expected_type].include?(value_class)).to eq(true), message
+    end
+
     def convert_to_date(value)
       begin
         DateTime.parse(value)
@@ -152,46 +180,18 @@ module Airborne
       end
     end
 
-    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"
-      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
+    def nil_optional_hash?(expected, hash)
+      expected.is_a?(Airborne::OptionalHashTypeExpectations) && hash.nil?
     end
 
-    def hash?(expected_class)
-      expected_class == Hash || expected_class == Airborne::OptionalHashTypeExpectations
+    def hash?(hash)
+      hash.is_a?(Hash) || hash.is_a?(Airborne::OptionalHashTypeExpectations)
     end
 
     def expect_array(value_class, prop_name, expected_type)
       expect(value_class).to eq(Array), "Expected #{prop_name}\n to be of type #{expected_type}\n got #{value_class} instead"
     end
 
-    def expect_json_impl(expectations, hash)
-      hash = hash.to_s if expectations.class == Regexp
-      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] }
-        expected_class = expected_value.class
-        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)
-      end
-    end
-
-    def ensure_hash_contains_prop(prop_name, hash)
-      begin
-        yield
-      rescue
-        raise ExpectationError, "Expected #{hash.class} #{hash}\nto be an object with property #{prop_name}"
-      end
-    end
-
     def convert_expectations_for_json_sizes(old_expectations)
       unless old_expectations.is_a?(Hash)
         return convert_expectation_for_json_sizes(old_expectations)
@@ -211,10 +211,47 @@ module Airborne
       ->(data) { expect(data.size).to eq(expected_size) }
     end
 
+    def ensure_hash_contains_prop(prop_name, hash)
+      begin
+        yield
+      rescue
+        raise ExpectationError, "Expected #{hash.class} #{hash}\nto be an object with property #{prop_name}"
+      end
+    end
+
     def property?(expectations)
       [String, Regexp, Float, Fixnum, Bignum, TrueClass, FalseClass, NilClass].include?(expectations.class)
     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],
+        date: [DateTime],
+        null: [NilClass]
+      }
+
+      mapper = base_mapper.clone
+      base_mapper.each do |key, value|
+        mapper[(key.to_s + '_or_null').to_sym] = value + [NilClass]
+      end
+      mapper
+    end
+
     def resolve_status(candidate, authority)
       candidate = Rack::Utils::SYMBOL_TO_STATUS_CODE[candidate] if candidate.is_a?(Symbol)
       case authority
@@ -223,5 +260,17 @@ module Airborne
       else candidate
       end
     end
+
+    def match_none?
+      !match_actual? && !match_expected?
+    end
+
+    def match_actual?
+      Airborne.configuration.match_actual?
+    end
+
+    def match_expected?
+      Airborne.configuration.match_expected?
+    end
   end
 end

data/spec/airborne/base_spec.rb

@@ -17,7 +17,7 @@ describe 'base spec' do
     mock_get('invalid_json')
     get '/invalid_json'
     expect(body).to eq('1234')
-    expect { json_body }.to raise_error
+    expect { json_body }.to raise_error(InvalidJsonError)
   end
 
   it 'when request is made headers should be hash with indifferent access' do

data/spec/airborne/expectations/expect_header_contains_spec.rb

@@ -10,12 +10,12 @@ describe 'expect header contains' do
   it 'should ensure header is present' do
     mock_get('simple_get', 'Content-Type' => 'application/json')
     get '/simple_get'
-    expect { expect_header_contains(:foo, 'bar') }.to raise_error
+    expect { expect_header_contains(:foo, 'bar') }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should ensure partial header is present' do
     mock_get('simple_get', 'Content-Type' => 'application/json')
     get '/simple_get'
-    expect { expect_header_contains(:content_type, 'bar') }.to raise_error
+    expect { expect_header_contains(:content_type, 'bar') }.to raise_error(ExpectationNotMetError)
   end
 end

data/spec/airborne/expectations/expect_header_spec.rb

@@ -10,12 +10,12 @@ describe 'expect header' do
   it 'should find exact match for header content' do
     mock_get('simple_get', 'Content-Type' => 'json')
     get '/simple_get'
-    expect { expect_header(:content_type, 'application/json') }.to raise_error
+    expect { expect_header(:content_type, 'application/json') }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should ensure correct headers are present' do
     mock_get('simple_get', 'Content-Type' => 'application/json')
     get '/simple_get'
-    expect { expect_header(:foo, 'bar') }.to raise_error
+    expect { expect_header(:foo, 'bar') }.to raise_error(ExpectationNotMetError)
   end
 end

data/spec/airborne/expectations/expect_json_keys_path_spec.rb

@@ -10,6 +10,6 @@ describe 'expect_json_keys with path' do
   it 'should fail when keys are missing with path' do
     mock_get('simple_nested_path')
     get '/simple_nested_path', {}
-    expect { expect_json_keys('address', [:bad]) }.to raise_error
+    expect { expect_json_keys('address', [:bad]) }.to raise_error(ExpectationNotMetError)
   end
 end

data/spec/airborne/expectations/expect_json_keys_spec.rb

@@ -4,7 +4,7 @@ describe 'expect_json_keys' do
   it 'should fail when json keys are missing' do
     mock_get('simple_json')
     get '/simple_json', {}
-    expect { expect_json_keys([:foo, :bar, :baz, :bax]) }.to raise_error
+    expect { expect_json_keys([:foo, :bar, :baz, :bax]) }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should ensure correct json keys' do

data/spec/airborne/expectations/expect_json_path_spec.rb

@@ -35,7 +35,7 @@ describe 'expect_json with path' do
   it 'should ensure at least one match' do
     mock_get('array_with_index')
     get '/array_with_index'
-    expect { expect_json('cars.?.make', 'Teslas') }.to raise_error
+    expect { expect_json('cars.?.make', 'Teslas') }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should check for at least one match' do
@@ -47,7 +47,7 @@ describe 'expect_json with path' do
   it 'should ensure at least one match' do
     mock_get('array_with_nested')
     get '/array_with_nested'
-    expect { expect_json('cars.?.owners.?', name: 'Bart Simpsons') }.to raise_error
+    expect { expect_json('cars.?.owners.?', name: 'Bart Simpsons') }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should check for one match that matches all ' do
@@ -65,13 +65,13 @@ describe 'expect_json with path' do
   it 'should ensure one match that matches all with lambda' do
     mock_get('array_with_nested')
     get '/array_with_nested'
-    expect { expect_json('cars.?.owners.*', name: ->(name) { expect(name).to eq('Bart Simpsons') }) }.to raise_error
+    expect { expect_json('cars.?.owners.*', name: ->(name) { expect(name).to eq('Bart Simpsons') }) }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should ensure one match that matches all' do
     mock_get('array_with_nested')
     get '/array_with_nested'
-    expect { expect_json('cars.?.owners.*', name: 'Bart Simpsons') }.to raise_error
+    expect { expect_json('cars.?.owners.*', name: 'Bart Simpsons') }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should allow indexing' do
@@ -103,6 +103,6 @@ describe 'expect_json with path' do
     get '/array_with_index'
     expect do
       expect_json('cars.0.make', make: 'Tesla')
-    end.to raise_error(Airborne::ExpectationError, "Expected String Tesla\nto be an object with property make")
+    end.to raise_error(ExpectationError, "Expected String Tesla\nto be an object with property make")
   end
 end

data/spec/airborne/expectations/expect_json_regex_spec.rb

@@ -10,7 +10,7 @@ describe 'expect_json regex' do
   it 'should raise an error if regex does not match' do
     mock_get('simple_get')
     get '/simple_get'
-    expect { expect_json(name: regex('^B')) }.to raise_error
+    expect { expect_json(name: regex('^B')) }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should allow regex(Regexp) to be tested against a path' do

data/spec/airborne/expectations/expect_json_spec.rb

@@ -10,7 +10,7 @@ describe 'expect_json' do
   it 'should fail when incorrect json is tested' do
     mock_get('simple_get')
     get '/simple_get'
-    expect { expect_json(bad: 'data') }.to raise_error
+    expect { expect_json(bad: 'data') }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should allow full object graph' do
@@ -18,10 +18,4 @@ describe 'expect_json' do
     get '/simple_path_get'
     expect_json(name: 'Alex', address: { street: 'Area 51', city: 'Roswell', state: 'NM' })
   end
-
-  it 'should ensure keys in hashes do match' do
-    mock_get('hash_property')
-    get '/hash_property'
-    expect { expect_json(person: { name: 'Alex', something: nil }) }.to raise_error
-  end
 end

data/spec/airborne/expectations/expect_json_types_options_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe 'expect_json_types options' do
+  describe 'match_expected', match_expected: true, match_actual: false do
+    it 'should require all expected properties' do
+      mock_get 'simple_get'
+      get '/simple_get'
+      expect{ expect_json_types(name: :string, other: :string) }.to raise_error(ExpectationNotMetError)
+    end
+
+    it 'should not require the actual properties' do
+      mock_get 'simple_get'
+      get '/simple_get'
+      expect_json_types(name: :string)
+    end
+  end
+
+  describe 'match_actual', match_expected: false, match_actual: true do
+    it 'should require all actual properties' do
+      mock_get 'simple_get'
+      get '/simple_get'
+      expect{ expect_json_types(name: :string) }.to raise_error(ExpectationError)
+    end
+
+    it 'should not require the expected properties' do
+      mock_get 'simple_get'
+      get '/simple_get'
+      expect_json_types(name: :string, age: :int, address: :null, other: :string)
+    end
+  end
+
+  describe 'match_both', match_expected: true, match_actual: true do
+    it 'should require all actual properties' do
+      mock_get 'simple_get'
+      get '/simple_get'
+      expect{ expect_json_types(name: :string) }.to raise_error(ExpectationError)
+    end
+
+    it 'should require all expected properties' do
+      mock_get 'simple_get'
+      get '/simple_get'
+      expect{ expect_json_types(name: :string, other: :string) }.to raise_error(ExpectationNotMetError)
+    end
+  end
+
+  describe 'match_none', match_expected: false, match_actual: false do
+    it 'should not require the actual properties' do
+      mock_get 'simple_get'
+      get '/simple_get'
+      expect_json_types(name: :string)
+    end
+
+    it 'should not require the expected properties' do
+      mock_get 'simple_get'
+      get '/simple_get'
+      expect_json_types(name: :string, age: :int, address: :null, other: :string)
+    end
+  end
+end

data/spec/airborne/expectations/expect_json_types_path_spec.rb

@@ -34,7 +34,7 @@ describe 'expect_json_types wih path' do
   it 'should ensure all elements of array are valid' do
     mock_get('array_with_index')
     get '/array_with_index'
-    expect { expect_json_types('cars.*', make: :string, model: :int) }.to raise_error
+    expect { expect_json_types('cars.*', make: :string, model: :int) }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should deep symbolize array responses' do
@@ -52,7 +52,7 @@ describe 'expect_json_types wih path' do
   it 'should ensure all nested arrays contain correct data' do
     mock_get('array_with_nested_bad_data')
     get '/array_with_nested_bad_data'
-    expect { expect_json_types('cars.*.owners.*', name: :string) }.to raise_error
+    expect { expect_json_types('cars.*.owners.*', name: :string) }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should raise ExpectationError when expectation expects an object instead of type' do
@@ -60,6 +60,6 @@ describe 'expect_json_types wih path' do
     get '/array_with_index'
     expect do
       expect_json_types('cars.0.make', make: :string)
-    end.to raise_error(Airborne::ExpectationError, "Expected String Tesla\nto be an object with property make")
+    end.to raise_error(ExpectationError, "Expected String Tesla\nto be an object with property make")
   end
 end

data/spec/airborne/expectations/expect_json_types_spec.rb

@@ -10,7 +10,7 @@ describe 'expect_json_types' do
   it 'should fail when incorrect json types tested' do
     mock_get('simple_get')
     get '/simple_get'
-    expect { expect_json_types(bad: :bool) }.to raise_error
+    expect { expect_json_types(bad: :bool) }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should not fail when optional property is not present' do
@@ -22,7 +22,7 @@ describe 'expect_json_types' do
   it 'should allow full object graph' do
     mock_get('simple_path_get')
     get '/simple_path_get'
-    expect_json_types(name: :string, address: { street: :string, city: :string, state: :string })
+    expect_json_types({name: :string, address: { street: :string, city: :string, state: :string }})
   end
 
   it 'should check all types in a simple array' do
@@ -34,7 +34,7 @@ describe 'expect_json_types' do
   it 'should ensure all valid types in a simple array' do
     mock_get('array_of_values')
     get '/array_of_values'
-    expect { expect_json_types(bad: :array_of_ints) }.to raise_error
+    expect { expect_json_types(bad: :array_of_ints) }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should allow empty array' do
@@ -52,6 +52,6 @@ describe 'expect_json_types' do
   it 'Should throw bad type error' do
     mock_get('simple_get')
     get '/simple_get'
-    expect { expect_json_types(name: :foo) }.to raise_error(Airborne::ExpectationError, "Expected type foo\nis an invalid type")
+    expect { expect_json_types(name: :foo) }.to raise_error(ExpectationError, "Expected type foo\nis an invalid type")
   end
 end

data/spec/airborne/expectations/expect_status_spec.rb

@@ -10,7 +10,7 @@ describe 'expect_status' do
   it 'should fail when incorrect status code is returned' do
     mock_get('simple_get')
     get '/simple_get'
-    expect { expect_status 123 }.to raise_error
+    expect { expect_status 123 }.to raise_error(ExpectationNotMetError)
   end
 
   it 'should translate symbol codes to whatever is appropriate for the request' do

data/spec/airborne/path_spec.rb

@@ -10,13 +10,13 @@ describe 'expect path' do
     it 'should raise PathError when incorrect path containing .. is used' do
       expect do
         expect_json('cars..make', 'Tesla')
-      end.to raise_error(Airborne::PathError, "Invalid Path, contains '..'")
+      end.to raise_error(PathError, "Invalid Path, contains '..'")
     end
 
     it 'should raise PathError when trying to call property on an array' do
       expect do
         expect_json('cars.make', 'Tesla')
-      end.to raise_error(Airborne::PathError, "Expected Array\nto be an object with property make")
+      end.to raise_error(PathError, "Expected Array\nto be an object with property make")
     end
   end
 

data/spec/airborne/rack/rack_sinatra_spec.rb

@@ -23,7 +23,7 @@ describe 'rack app' do
 
   it 'should ensure correct values from sinatra app' do
     get '/'
-    expect { expect_json_types(foo: :int) }.to raise_error
+    expect { expect_json_types(foo: :int) }.to raise_error(ExpectationNotMetError)
   end
 
   it 'Should set json_body even when not using the airborne http requests' do

data/spec/spec_helper.rb

@@ -7,3 +7,8 @@ Airborne.configure do |config|
   config.base_url = 'http://www.example.com'
   config.include StubHelper
 end
+
+ExpectationNotMetError = RSpec::Expectations::ExpectationNotMetError
+ExpectationError       = Airborne::ExpectationError
+InvalidJsonError       = Airborne::InvalidJsonError
+PathError              = Airborne::PathError

data/spec/stub_helper.rb

@@ -40,6 +40,6 @@ module StubHelper
   private
 
   def get_json_response_file(name)
-    IO.read(File.join('spec/test_responses', name + '.json'))
+    IO.read("spec/test_responses/#{name}.json")
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: airborne
 version: !ruby/object:Gem::Version
-  version: 0.1.20
+  version: 0.2.0
 platform: ruby
 authors:
 - Alex Friedman
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-24 00:00:00.000000000 Z
+date: 2015-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -136,6 +136,7 @@ files:
 - spec/airborne/expectations/expect_json_types_date_spec.rb
 - spec/airborne/expectations/expect_json_types_lambda_spec.rb
 - spec/airborne/expectations/expect_json_types_optional_spec.rb
+- spec/airborne/expectations/expect_json_types_options_spec.rb
 - spec/airborne/expectations/expect_json_types_path_spec.rb
 - spec/airborne/expectations/expect_json_types_spec.rb
 - spec/airborne/expectations/expect_status_spec.rb
@@ -187,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.5
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: RSpec driven API testing framework