airborne 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 5f2674eef0b9d537ac538d0b0c5610adca03e5a63ad3a5755d409afab9641fe7
-  data.tar.gz: 36d18e03c11ef4e9ae2d41e88d75bc8719899b541eec5572be393f426a3fd933
+SHA1:
+  metadata.gz: 4d361645e26853ce3f56827cc2bd1dbf0742f58d
+  data.tar.gz: ce83f9aa0ab23bcda5917e179e1c0b8525f805fb
 SHA512:
-  metadata.gz: fcc9fe452b86c3fb2938dedd21dbbb51e05b64a8eb5721114246458134684a01dbf89ef864c27b0cba602e3158c8cd4aa1efeea0446bc59ed41a32ae3dfc4121
-  data.tar.gz: 9d7d2316ca24842d9190b5e6850c3813384af3708917f5c92d7b5a72f2f613a392d8d849e8b85de7c480a51a8dbb1c5ba74ac4bc56bbdd89efc0543e4b8908be
+  metadata.gz: 41aaab8803c8750dd2cc8d16043cc76d15b75d0cd3bd6df791f05703d42c8816a0d7fcc525bf699ec03e013ef6f17d5ae3dd9a87eedf0f59103da53f916e82a1
+  data.tar.gz: b99f18a689e857aa156de77471e7908b1859ac5e3afa83735c0154b17ffa416ad7c64642dc07204b7ba116f2c54070dfd444f091ff3ef915af1cc6fa4c47bce8

data/README.md

@@ -1,4 +1,4 @@
-# Airborne 
+# Airborne
 
 [![airborne travis](http://img.shields.io/travis/brooklynDev/airborne.svg?branch=master&style=flat-square)](https://travis-ci.org/brooklynDev/airborne)
 [![airborne coveralls](http://img.shields.io/coveralls/brooklynDev/airborne/master.svg?style=flat-square)](https://coveralls.io/r/brooklynDev/airborne?branch=master)
@@ -156,6 +156,57 @@ For requests that require Query params you can pass a params hash into headers.
 post 'http://example.com/api/v1/my_api', { }, { 'params' => {'param_key' => 'param_value' } }
 ```
 
+### (Not) Verifying SSL Certificates
+
+SSL certificate verification is enabled by default (specifically, `OpenSSL::SSL::VERIFY_PEER`).
+
+Carefully consider how you use this. It's not a solution for getting around a failed SSL cert verification; rather, it's intended for testing systems that don't have a legitimate SSL cert, such as a development or test environment.
+
+You can override this behavior per request:
+
+```ruby
+verify_ssl = false
+post 'http://example.com/api/v1/my_api', "Hello there!", { content_type: 'text/plain' }, verify_ssl
+```
+
+or with a global Airborne configuration:
+
+```ruby
+Airborne.configure do |config|
+  config.verify_ssl = false # equivalent to OpenSSL::SSL::VERIFY_NONE
+end
+```
+
+Note the per-request option always overrides the Airborne configuration:
+
+```ruby
+before do
+  Airborne.configuration.verify_ssl = false
+end
+
+it 'will still verify the SSL certificate' do
+  verify_ssl = true
+  post 'http://example.com/api/v1/my_api', "Hello there!", { content_type: 'text/plain' }, verify_ssl
+end
+```
+
+You can use the `verify_ssl` setting to override your global defaults in test blocks like this:
+
+```ruby
+describe 'test something', verify_ssl: false do
+end
+```
+
+OR
+
+```ruby
+describe 'test something' do
+  Airborne.configuration.verify_ssl = false
+end
+```
+
+This feature currently isn't supported when testing loaded Rack applications (see "Testing Rack Applications" below). If you need to set `verify_ssl: false`, then we recommend starting your Rack app server and sending the `airborne` HTTP requests as you would when testing any other service.
+
 ## 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:
@@ -238,7 +289,7 @@ it 'should allow nested paths' do
 end
 ```
 
-Alternativley, if we only want to test `coordinates` we can dot into just the `coordinates`:
+Alternatively, if we only want to test `coordinates` we can dot into just the `coordinates`:
 
 ```ruby
 it 'should allow nested paths' do

data/airborne.gemspec

@@ -2,7 +2,7 @@ require 'date'
 
 Gem::Specification.new do |s|
   s.name        = 'airborne'
-  s.version     = '0.3.2'
+  s.version     = '0.3.3'
   s.date        = Date.today.to_s
   s.summary = 'RSpec driven API testing framework'
   s.authors     = ['Alex Friedman', 'Seth Pollack']
@@ -15,5 +15,5 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'rack-test', '< 2.0', '>= 1.1.0'
   s.add_runtime_dependency 'rack'
   s.add_runtime_dependency 'activesupport'
-  s.add_development_dependency 'webmock', '~> 0'
+  s.add_development_dependency 'webmock', '~> 3'
 end

data/lib/airborne.rb

@@ -15,11 +15,14 @@ RSpec.configure do |config|
   config.add_setting :rack_app
   config.add_setting :requester_type
   config.add_setting :requester_module
+  config.add_setting :verify_ssl, default: true
   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]
+    config.verify_ssl = example.metadata[:verify_ssl].nil? ?
+      Airborne.configuration.verify_ssl? : example.metadata[:verify_ssl]
   end
 
   # Include last since it depends on the configuration already being added

data/lib/airborne/base.rb

@@ -29,24 +29,24 @@ module Airborne
     RSpec.configuration
   end
 
-  def get(url, headers = nil)
-    @response = make_request(:get, url, headers: headers)
+  def get(url, headers = nil, verify_ssl = base_verify_ssl)
+    @response = make_request(:get, url, headers: headers, verify_ssl: verify_ssl)
   end
 
-  def post(url, post_body = nil, headers = nil)
-    @response = make_request(:post, url, body: post_body, headers: headers)
+  def post(url, post_body = nil, headers = nil, verify_ssl = base_verify_ssl)
+    @response = make_request(:post, url, body: post_body, headers: headers, verify_ssl: verify_ssl)
   end
 
-  def patch(url, patch_body = nil, headers = nil)
-    @response = make_request(:patch, url, body: patch_body, headers: headers)
+  def patch(url, patch_body = nil, headers = nil, verify_ssl = base_verify_ssl)
+    @response = make_request(:patch, url, body: patch_body, headers: headers, verify_ssl: verify_ssl)
   end
 
-  def put(url, put_body = nil, headers = nil)
-    @response = make_request(:put, url, body: put_body, headers: headers)
+  def put(url, put_body = nil, headers = nil, verify_ssl = base_verify_ssl)
+    @response = make_request(:put, url, body: put_body, headers: headers, verify_ssl: verify_ssl)
   end
 
-  def delete(url, delete_body = nil, headers = nil)
-    @response = make_request(:delete, url, body: delete_body, headers: headers)
+  def delete(url, delete_body = nil, headers = nil, verify_ssl = base_verify_ssl)
+    @response = make_request(:delete, url, body: delete_body, headers: headers, verify_ssl: verify_ssl)
   end
 
   def head(url, headers = nil)
@@ -79,4 +79,8 @@ module Airborne
     base = Airborne.configuration.base_url || ''
     base + url
   end
+
+  def base_verify_ssl
+    Airborne.configuration.verify_ssl || false
+  end
 end

data/lib/airborne/rest_client_requester.rb

@@ -4,17 +4,29 @@ module Airborne
   module RestClientRequester
     def make_request(method, url, options = {})
       headers = base_headers.merge(options[:headers] || {})
+      verify_ssl = options.fetch(:verify_ssl, true)
       res = if method == :post || method == :patch || method == :put
         begin
           request_body = options[:body].nil? ? '' : options[:body]
           request_body = request_body.to_json if is_json_request(headers)
-          RestClient.send(method, get_url(url), request_body, headers){|response, request, result| response }
+          RestClient::Request.execute(
+            method: method,
+            url: get_url(url),
+            payload: request_body,
+            headers: headers,
+            verify_ssl: verify_ssl
+          ) { |response, request, result| response }
         rescue RestClient::Exception => e
           e.response
         end
       else
         begin
-          RestClient.send(method, get_url(url), headers){|response, request, result| response }
+          RestClient::Request.execute(
+            method: method,
+            url: get_url(url),
+            headers: headers,
+            verify_ssl: verify_ssl
+          ) { |response, request, result| response }
         rescue RestClient::Exception => e
           e.response
         end

data/spec/airborne/client_requester_spec.rb

@@ -2,27 +2,36 @@ require 'spec_helper'
 
 describe 'client requester' do
   before do
-    allow(RestClient).to receive(:send)
+    allow(RestClient::Request).to receive(:execute)
     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 =  {} }
+    allow(RestClient::Request).to receive(:execute).and_call_original
+    Airborne.configure { |config| config.headers = {} }
+    Airborne.configure { |config| config.verify_ssl = true }
   end
 
   it 'should set :content_type to :json by default' do
     get '/foo'
 
-    expect(RestClient).to have_received(:send)
-                            .with(:get, 'http://www.example.com/foo', { content_type: :json })
+    expect(RestClient::Request).to have_received(:execute).with(
+      method: :get,
+      url: 'http://www.example.com/foo',
+      headers: { content_type: :json },
+      verify_ssl: true
+    )
   end
 
   it 'should override headers with option[:headers]' do
     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' })
+    expect(RestClient::Request).to have_received(:execute).with(
+      method: :get,
+      url: 'http://www.example.com/foo',
+      headers: { content_type: 'application/x-www-form-urlencoded' },
+      verify_ssl: true
+    )
   end
 
   it 'should override headers with airborne config headers' do
@@ -30,28 +39,147 @@ describe 'client requester' do
 
     get '/foo'
 
-    expect(RestClient).to have_received(:send)
-                            .with(:get, 'http://www.example.com/foo', { content_type: 'text/plain' })
+    expect(RestClient::Request).to have_received(:execute).with(
+      method: :get,
+      url: 'http://www.example.com/foo',
+      headers: { content_type: 'text/plain' },
+      verify_ssl: true
+    )
   end
 
   it 'should serialize body to json when :content_type is (default) :json' do
     post '/foo', { test: 'serialized' }
 
-    expect(RestClient).to have_received(:send)
-                            .with(:post, 'http://www.example.com/foo', '{"test":"serialized"}', { content_type: :json })
+    expect(RestClient::Request).to have_received(:execute).with(
+      method: :post,
+      url: 'http://www.example.com/foo',
+      payload: { test: 'serialized' }.to_json,
+      headers: { content_type: :json },
+      verify_ssl: true
+    )
   end
 
   it 'should serialize body to json when :content_type is any enhanced JSON content type' do
     post '/foo', { test: 'serialized' }, { content_type: 'application/vnd.airborne.2+json' }
 
-    expect(RestClient).to have_received(:send)
-                            .with(:post, 'http://www.example.com/foo', '{"test":"serialized"}', { content_type: 'application/vnd.airborne.2+json' })
+    expect(RestClient::Request).to have_received(:execute).with(
+      method: :post,
+      url: 'http://www.example.com/foo',
+      payload: { test: 'serialized' }.to_json,
+      headers: { content_type: 'application/vnd.airborne.2+json' },
+      verify_ssl: true
+    )
   end
 
   it 'should not serialize body to json when :content_type does not match JSON' do
     post '/foo', { test: 'not serialized' }, { content_type: 'text/plain' }
 
-    expect(RestClient).to have_received(:send)
-                            .with(:post, 'http://www.example.com/foo', { test: 'not serialized' }, { content_type: 'text/plain' })
+    expect(RestClient::Request).to have_received(:execute).with(
+      method: :post,
+      url: 'http://www.example.com/foo',
+      payload: { test: 'not serialized' },
+      headers: { content_type: 'text/plain' },
+      verify_ssl: true
+    )
+  end
+
+  context 'verify_ssl' do
+    it 'should be true by default' do
+      get '/foo'
+
+      expect(RestClient::Request).to have_received(:execute).with(
+        method: :get,
+        url: 'http://www.example.com/foo',
+        headers: { content_type: :json },
+        verify_ssl: true
+      )
+    end
+
+    it 'should be set by airborne config' do
+      Airborne.configure { |config| config.verify_ssl = false }
+
+      get '/foo'
+
+      expect(RestClient::Request).to have_received(:execute).with(
+        method: :get,
+        url: 'http://www.example.com/foo',
+        headers: { content_type: :json },
+        verify_ssl: false
+      )
+    end
+
+    it 'should be overriden with options[:verify_ssl]' do
+      get '/foo', nil, false
+
+      expect(RestClient::Request).to have_received(:execute).with(
+        method: :get,
+        url: 'http://www.example.com/foo',
+        headers: { content_type: :json },
+        verify_ssl: false
+      )
+    end
+
+    it 'should override airborne config with options[:verify_ssl]' do
+      Airborne.configure { |config| config.verify_ssl = false }
+
+      get '/foo', nil, true
+
+      expect(RestClient::Request).to have_received(:execute).with(
+        method: :get,
+        url: 'http://www.example.com/foo',
+        headers: { content_type: :json },
+        verify_ssl: true
+      )
+    end
+
+    it 'should interpret airborne "config.verify_ssl = nil" as false' do
+      Airborne.configure { |config| config.verify_ssl = nil }
+
+      get '/foo'
+
+      expect(RestClient::Request).to have_received(:execute).with(
+        method: :get,
+        url: 'http://www.example.com/foo',
+        headers: { content_type: :json },
+        verify_ssl: false
+      )
+    end
+
+    context 'rspec metadata', verify_ssl: false do
+      it 'should override the base airborne config with the rspec metadata' do
+        get '/foo'
+
+        expect(RestClient::Request).to have_received(:execute).with(
+          method: :get,
+          url: 'http://www.example.com/foo',
+          headers: { content_type: :json },
+          verify_ssl: false
+        )
+      end
+
+      it 'should be overriden with options[:verify_ssl]' do
+        get '/foo', nil, true
+
+        expect(RestClient::Request).to have_received(:execute).with(
+          method: :get,
+          url: 'http://www.example.com/foo',
+          headers: { content_type: :json },
+          verify_ssl: true
+        )
+      end
+
+      it 'should be overriden by supplied airborne config' do
+        Airborne.configure { |config| config.verify_ssl = true }
+
+        get '/foo'
+
+        expect(RestClient::Request).to have_received(:execute).with(
+          method: :get,
+          url: 'http://www.example.com/foo',
+          headers: { content_type: :json },
+          verify_ssl: true
+        )
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: airborne
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Alex Friedman
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-25 00:00:00.000000000 Z
+date: 2019-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -29,42 +29,42 @@ dependencies:
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.0.2
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.0.2
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -99,14 +99,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 description: 
 email:
 - a.friedman07@gmail.com
@@ -200,7 +200,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubyforge_project: 
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: RSpec driven API testing framework