airborne 0.0.17 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 617736e61c4229477118c5e4c6f9b36e6a84ba3a
-  data.tar.gz: 4fa7413cdb076f955e9710dd04f1ebc5cb722f29
+  metadata.gz: c02499ba105b2a0cf64b2b3f66b3cb0603cdecff
+  data.tar.gz: 80406ace55d569bbabfd7a103f0135e4a37357b5
 SHA512:
-  metadata.gz: 81987ab36bcf03af95ccb687409c83df3debec95ce9981c7113320c981936ad27099f5dcc5816fdec2c156e1d635d3b23c37887e9e8edb6ec5e8a994f827dd76
-  data.tar.gz: 4144d3be1dee4d53e318ed696c4fa7ef8f97652ce5462fe631e42c9f9458d2ac2c8375ca27c71847342268fca866a12f63058cdca23f526e60ec983173c8ab4a
+  metadata.gz: 2a1e7465a8e9b57cd98b8ac94c93f6cf0c890cf660905da806c3a768ef36a0f897a143c35afa52a704b6a2ed9bf8b0e4b3a87825e7c47e4b134ae74baf8caadd
+  data.tar.gz: 4bbccbf924040c02119972fab3582cab6b71119d8696e0a385f8840389f3023b8ceb23af6d91606d34a50fa98416a081b015b9901573fe04c665d2a257e49993

data/README.md

@@ -8,25 +8,32 @@
 RSpec driven API testing framework inspired by [frisby.js](https://github.com/vlucas/frisby)
 
 ## Installation
+
 Install Airborne:
 
     gem install airborne
+    
+Or add it to your Gemfile:
+
+    gem 'airborne'
 
 ##Creating Tests
 
-    require 'airborne'
-    
-    describe 'sample spec' do
-        it 'should validate types' do
-            get 'http://example.com/api/v1/simple_get' #json api that returns { "name" : "John Doe" } 
-            expect_json_types({name: :string})
-        end
-        
-        it 'should validate values' do 
-            get 'http://example.com/api/v1/simple_get' #json api that returns { "name" : "John Doe" } 
-            expect_json({:name => "John Doe"})
-        end
-    end
+```ruby
+require 'airborne'
+
+describe 'sample spec' do
+  it 'should validate types' do
+    get 'http://example.com/api/v1/simple_get' #json api that returns { "name" : "John Doe" } 
+    expect_json_types({name: :string})
+  end
+
+  it 'should validate values' do 
+    get 'http://example.com/api/v1/simple_get' #json api that returns { "name" : "John Doe" } 
+    expect_json({:name => "John Doe"})
+  end
+end
+```
 
 When calling expect_json_types, these are the valid types that can be tested against:
 
@@ -45,31 +52,37 @@ When calling expect_json_types, these are the valid types that can be tested aga
 
 If the properties are optional and may not appear in the response, you can append `_or_null` to the types above.
     
-    describe 'sample spec' do
-        it 'should validate types' do
-            get 'http://example.com/api/v1/simple_get' #json api that returns { "name" : "John Doe" } or { "name" : "John Doe", "age" : 45 }
-            expect_json_types({name: :string, age: :int_or_null})
-        end
-    end
+```ruby
+describe 'sample spec' do
+  it 'should validate types' do
+    get 'http://example.com/api/v1/simple_get' #json api that returns { "name" : "John Doe" } or { "name" : "John Doe", "age" : 45 }
+    expect_json_types({name: :string, age: :int_or_null})
+  end
+end
+```
 
 Additionally, if an entire object could be null, but you'd still want to test the types if it does exist, you can wrap the expectations in a call to `optional`:
 
-    it 'should allow optional nested hash' do
-        get '/simple_path_get' #may or may not return coordinates
-        expect_json_types("address.coordinates", optional({lattitude: :float, longitutde: :float}))
-    end
+```ruby
+it 'should allow optional nested hash' do
+  get '/simple_path_get' #may or may not return coordinates
+  expect_json_types("address.coordinates", optional({lattitude: :float, longitutde: :float}))
+end
+```
 
-When calling `expect_json`, you can optionally provide a block and run your own `rspec` expectations:
+When calling `expect_json` or `expect_json_types`, you can optionally provide a block and run your own `rspec` expectations:
 
-    describe 'sample spec' do
-        it 'should validate types' do
-            get 'http://example.com/api/v1/simple_get' #json api that returns { "name" : "John Doe" }
-            expect_json({name: lambda |name| expect(name.length).to eq(8)})
-        end
-    end
-    
+```ruby
+describe 'sample spec' do
+  it 'should validate types' do
+    get 'http://example.com/api/v1/simple_get' #json api that returns { "name" : "John Doe" }
+    expect_json({name: -> (name){expect(name.length).to eq(8)}})
+  end
+end
+```
 
 ##Making requests
+
 Airborne uses `rest_client` to make the HTTP request, and supports all HTTP verbs. When creating a test, you can call any of the following methods: `get`, `post`, `put`, `patch`, `delete`. This will then give you access the following properties:
 
 * `response` - The HTTP response returned from the request
@@ -79,22 +92,28 @@ Airborne uses `rest_client` to make the HTTP request, and supports all HTTP verb
 
 Fo example:
 
-    it 'should validate types' do
-        get 'http://example.com/api/v1/simple_get' #json api that returns { "name" : "John Doe" } 
-        name = json_body[:name] #name will equal "John Doe"
-        body_as_string = body
-    end
-
+```ruby
+it 'should validate types' do
+  get 'http://example.com/api/v1/simple_get' #json api that returns { "name" : "John Doe" } 
+  name = json_body[:name] #name will equal "John Doe"
+  body_as_string = body
+end
+```
 
 When calling any of the methods above, you can pass request headers to be used. 
 
-    get 'http://example.com/api/v1/my_api', {'x-auth-token' => 'my_token'}
+```ruby
+get 'http://example.com/api/v1/my_api', {'x-auth-token' => 'my_token'}
+```
 
 For requests that require a body (`post`, `put`, `patch`) you can pass the body as a hash as well:
     
-    post 'http://example.com/api/v1/my_api', {:name => 'John Doe'}, {'x-auth-token' => 'my_token'}
-    
+```ruby
+post 'http://example.com/api/v1/my_api', {:name => 'John Doe'}, {'x-auth-token' => 'my_token'}
+```
+  
 ##API
+
 * `expect_json_types` - Tests the types of the JSON property values returned
 * `expect_json` - Tests the values of the JSON property values returned
 * `expect_json_keys` - Tests the existence of the specified keys in the JSON object
@@ -103,114 +122,148 @@ For requests that require a body (`post`, `put`, `patch`) you can pass the body
 * `expect_header_contains` - Partial match test on a specified header
 
 ##Path Matching
+
 When calling `expect_json_types`, `expect_json` or `expect_json_keys` you can optionaly specify a path as a first parameter. 
 
 For example, if our API returns the following JSON:
 
-    {
-        "name": "Alex",
-        "address": {
-            "street": "Area 51",
-            "city": "Roswell",
-            "state": "NM",
-            "coordinates":{
-                "lattitude": 33.3872,
-                "longitude": 104.5281 
-            }
-        }
+```json
+{
+  "name": "Alex",
+  "address": {
+    "street": "Area 51",
+    "city": "Roswell",
+    "state": "NM",
+    "coordinates": {
+      "lattitude": 33.3872,
+      "longitude": 104.5281
     }
+  }
+}
+```
     
 This test would only test the address object:
     
-    describe 'path spec' do
-        it 'should allow simple path and verify only that path' do
-            get 'http://example.com/api/v1/simple_path_get'
-            expect_json_types('address', {street: :string, city: :string, state: :string, coordinates: :object })
-            #or this
-            expect_json_types('address', {street: :string, city: :string, state: :string, coordinates: { lattitude: :float, longitude: :float } })
-        end
-    end
+```ruby
+describe 'path spec' do
+  it 'should allow simple path and verify only that path' do
+    get 'http://example.com/api/v1/simple_path_get'
+    expect_json_types('address', {street: :string, city: :string, state: :string, coordinates: :object })
+    #or this
+    expect_json_types('address', {street: :string, city: :string, state: :string, coordinates: { lattitude: :float, longitude: :float } })
+  end
+end
+```
 
 Alternativley, if we only want to test `coordinates` we can dot into just the `coordinates`:
 
-    it 'should allow nested paths' do
-        get 'http://example.com/api/v1/simple_path_get'
-        expect_json('address.coordinates', {lattitude: 33.3872, longitutde: 104.5281} )     
-    end
+```ruby
+it 'should allow nested paths' do
+  get 'http://example.com/api/v1/simple_path_get'
+  expect_json('address.coordinates', {lattitude: 33.3872, longitutde: 104.5281} )     
+end
+```
 
 When dealing with `arrays`, we can optionally test all (`*`) or a single (`?` - any, `0` - index) element of the array:
 
 Given the following JSON:
 
+```json
+{
+  "cars": [
+    {
+      "make": "Tesla",
+      "model": "Model S"
+    },
     {
-        "cars":[
-            {"make": "Tesla", "model": "Model S"},
-            {"make": "Lamborghini", "model": "Aventador"}
-        ]
+      "make": "Lamborghini",
+      "model": "Aventador"
     }
+  ]
+}
+```
 
 We can test against just the first car like this:
 
-    it 'should index into array and test against specific element' do 
-        get '/array_api'
-        expect_json('cars.0', {make: "Tesla", model: "Model S"})
-    end
+```ruby
+it 'should index into array and test against specific element' do 
+  get '/array_api'
+  expect_json('cars.0', {make: "Tesla", model: "Model S"})
+end
+```
 
 To test the types of all elements in the array:
 
-    it 'should test all elements of the array' do 
-        get 'http://example.com/api/v1/array_api
-        expect_json('cars.?', {make: "Tesla", model: "Model S"}) # tests that one car in array matches the tesla
-        expect_json_types('cars.*', {make: :string, model: :string}) # tests all cars in array for make and model of type string
-    end
+```ruby
+it 'should test all elements of the array' do 
+  get 'http://example.com/api/v1/array_api'
+  expect_json('cars.?', {make: "Tesla", model: "Model S"}) # tests that one car in array matches the tesla
+  expect_json_types('cars.*', {make: :string, model: :string}) # tests all cars in array for make and model of type string
+end
+```
     
 `*` and `?` work for nested arrays as well. Given the following JSON:
 
+```json
+{
+  "cars": [
     {
-        "cars": [{
-            "make": "Tesla",
-            "model": "Model S",
-            "owners": [{
-                "name": "Bart Simpson"
-            }]
-        }, {
-            "make": "Lamborghini",
-            "model": "Aventador",
-            "owners": [{
-                "name": "Peter Griffin"
-            }]
-        }]
+      "make": "Tesla",
+      "model": "Model S",
+      "owners": [
+        {
+          "name": "Bart Simpson"
+        }
+      ]
+    },
+    {
+      "make": "Lamborghini",
+      "model": "Aventador",
+      "owners": [
+        {
+          "name": "Peter Griffin"
+        }
+      ]
     }
+  ]
+}
+```
 
 ===
 
-    it 'should check all nested arrays for specified elements' do
-        get 'http://example.com/api/v1/array_with_nested'
-        expect_json_types('cars.*.owners.*', {name: :string})
-    end
-    
+```ruby
+it 'should check all nested arrays for specified elements' do
+  get 'http://example.com/api/v1/array_with_nested'
+  expect_json_types('cars.*.owners.*', {name: :string})
+end
+```
 
 ##Configuration
 
 When setting up Airborne, you can call `configure` just like you would with `rspec`:
 
-    Airborne.configure.do |config| #config is the RSpec configuration and can be used just like it
-        config.include MyModule
-    end
+```ruby
+#config is the RSpec configuration and can be used just like it
+Airborne.configure.do |config|
+  config.include MyModule
+end
+```
 
 Additionally, you can specify a `base_url` and default `headers` to be used on every request (unless overriden in the actual request):
 
-    Airborne.configure.do |config|
-        config.base_url = 'http://example.com/api/v1'
-        config.headers = {'x-auth-token' => 'my_token'}
-    end
-    
-    describe 'spec' do
-        it 'now we no longer need the full url' do
-            get '/simple_get'
-            expect_json_types({name: :string})
-        end
-    end
+```ruby
+Airborne.configure.do |config|
+  config.base_url = 'http://example.com/api/v1'
+  config.headers = {'x-auth-token' => 'my_token'}
+end
+
+describe 'spec' do
+  it 'now we no longer need the full url' do
+    get '/simple_get'
+    expect_json_types({name: :string})
+  end
+end
+```
 
 ## License 
 

data/airborne.gemspec

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

data/lib/airborne/path_matcher.rb

@@ -7,9 +7,9 @@ module Airborne
 				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 - 1
+					if index < parts.length.pred
 						json.each do |element|
-							sub_path = parts[(index + 1)..(parts.length-1)].join('.')
+							sub_path = parts[(index.next)...(parts.length)].join('.')
 							get_by_path(sub_path, element, &block)
 						end
 						return
@@ -21,7 +21,7 @@ module Airborne
 					json = json[part]
 				else
 					json = json[part.to_sym]
-					raise "Expected #{path} to be object or array got #{json.class} from JSON response" unless json.class == Array || json.class == Hash || json.nil?
+					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 == '*'

data/lib/airborne/request_expectations.rb

@@ -97,6 +97,8 @@ module Airborne
 				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|
@@ -111,9 +113,9 @@ module Airborne
 		def expect_json_impl(expectations, hash)
 			expectations.each do |prop_name, expected_value|
 				actual_value = hash[prop_name]
-				if(expected_value.class == Hash)
+				if expected_value.class == Hash
 					expect_json_impl(expected_value, actual_value)
-				elsif(expected_value.class == Proc)
+				elsif expected_value.class == Proc
 					expected_value.call(actual_value)
 				else
 					expect(expected_value).to eq(actual_value)

data/spec/airborne/expect_json_types_spec.rb

@@ -96,4 +96,10 @@ describe 'expect_json_types' do
 		get '/simple_path_get'
 		expect_json_types("address.coordinates", optional({lattitude: :float, longitutde: :float}))
 	end
+
+	it 'should invoke proc passed in' do
+		mock_get('simple_get')
+		get '/simple_get'
+		expect_json_types({name: -> (name){expect(name.length).to eq(4)}})
+	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: airborne
 version: !ruby/object:Gem::Version
-  version: 0.0.17
+  version: 0.0.18
 platform: ruby
 authors:
 - Alex Friedman