hops-airborne 0.2.15

data/lib/airborne/path_matcher.rb

@@ -0,0 +1,101 @@
+module Airborne
+  class PathError < StandardError; end
+
+  module PathMatcher
+    def get_by_path(path, json, &block)
+      fail PathError, "Invalid Path, contains '..'" if /\.\./ =~ path
+      type = false
+      parts = path.split('.')
+      parts.each_with_index do |part, index|
+        if part == '*' || part == '?'
+          ensure_array(path, json)
+          type = part
+          if index < parts.length.pred
+            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 be an object with property #{part}"
+        end
+      end
+      if type == '*'
+        expect_all(json, &block)
+      elsif type == '?'
+        expect_one(path, json, &block)
+      else
+        yield json
+      end
+    end
+
+    private
+
+    def walk_with_path(type, index, path, parts, json, &block)
+      last_error  = nil
+      item_count = json.length
+      error_count = 0
+      json.each do |element|
+        begin
+          sub_path = parts[(index.next)...(parts.length)].join('.')
+          get_by_path(sub_path, element, &block)
+        rescue Exception => e
+          last_error = e
+          error_count += 1
+        end
+        ensure_match_all(last_error) if type == '*'
+        ensure_match_one(path, item_count, error_count) if type == '?'
+      end
+    end
+
+    def process_json(part, json)
+      if index?(part) && json.is_a?(Array)
+        part = part.to_i
+        json = json[part]
+      else
+        json = json[part.to_sym]
+      end
+      json
+    end
+
+    def index?(part)
+      part =~ /^\d+$/
+    end
+
+    def expect_one(path, json, &block)
+      item_count = json.length
+      error_count = 0
+      json.each do |part|
+        begin
+          yield part
+        rescue Exception
+          error_count += 1
+          ensure_match_one(path, item_count, error_count)
+        end
+      end
+    end
+
+    def expect_all(json, &block)
+      last_error = nil
+      begin
+        json.each { |part| yield part }
+      rescue Exception => e
+        last_error = e
+      end
+      ensure_match_all(last_error)
+    end
+
+    def ensure_match_one(path, 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)
+      fail error unless error.nil?
+    end
+
+    def ensure_array(path, json)
+      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

@@ -0,0 +1,18 @@
+require 'rack/test'
+
+module Airborne
+  module RackTestRequester
+    def make_request(method, url, options = {})
+      headers = options[:headers] || {}
+      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
+      end
+      browser.last_response
+    end
+  end
+end

data/lib/airborne/request_expectations.rb

@@ -0,0 +1,285 @@
+require 'rspec'
+require 'date'
+require 'rack/utils'
+
+module Airborne
+  class ExpectationError < StandardError; end
+  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(*args)
+      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_sizes(*args)
+      args.push(convert_expectations_for_json_sizes(args.pop))
+
+      expect_json_types(*args)
+    end
+
+    def expect_status(code)
+      expect(response.code).to eq(resolve_status(code, response.code))
+    end
+
+    def expect_header(key, content)
+      expect_header_impl(key, content)
+    end
+
+    def expect_header_contains(key, content)
+      expect_header_impl(key, content, true)
+    end
+
+    def optional(hash)
+      OptionalHashTypeExpectations.new(hash)
+    end
+
+    def regex(reg)
+      Regexp.new(reg)
+    end
+
+    def date
+      ->(value) { yield DateTime.parse(value) }
+    end
+
+    private
+
+    def expect_header_impl(key, content, contains = nil)
+      header = headers[key]
+      if header
+        if contains
+          expect(header.downcase).to include(content.downcase)
+        else
+          expect(header.downcase).to eq(content.downcase)
+        end
+      else
+        fail RSpec::Expectations::ExpectationNotMetError, "Header #{key} not present in the HTTP response"
+      end
+    end
+
+    def expect_json_impl(expected, actual)
+      return if nil_optional_hash?(expected, actual)
+
+      actual = actual.to_s if expected.is_a?(Regexp)
+
+      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_value(expected, prop)
+        actual_value    = extract_actual(actual, prop)
+
+        next expect_json_impl(expected_value, actual_value) if hash?(expected_value) && hash?(actual_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
+    end
+
+    def expect_json_types_impl(expected, actual)
+      return if nil_optional_hash?(expected, actual)
+
+      @mapper ||= get_mapper
+
+      actual = convert_to_date(actual) if ((expected == :date) || (expected == :date_or_null))
+
+      return expect_type(expected, actual) if expected.is_a?(Symbol)
+      return expected.call(actual) if expected.is_a?(Proc)
+
+      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|
+        type  = extract_expected_type(expected, prop)
+        value = extract_actual(actual, prop)
+        value = convert_to_date(value) if ((type == :date) || (type == :date_or_null))
+
+        next expect_json_types_impl(type, value) if hash?(type)
+        next type.call(value) if type.is_a?(Proc)
+
+        type_string = type.to_s
+
+        if type_string.include?('array_of') && !(type_string.include?('or_null') && value.nil?)
+          check_array_types(value, prop, type)
+        else
+          expect_type(type, value, 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_value(expected, prop)
+      begin
+        raise unless expected.keys.include?(prop)
+        expected[prop]
+      rescue
+        raise ExpectationError, "Expectation is expected to contain property: #{prop}"
+      end
+    end
+
+    def extract_expected_type(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, 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].any?{|type| value.is_a?(type)}).to eq(true), message
+    end
+
+    def convert_to_date(value)
+      begin
+        DateTime.parse(value)
+      rescue
+      end
+    end
+
+    def check_array_types(value, prop_name, expected_type)
+      expect_array(value, prop_name, expected_type)
+      value.each do |val|
+        expect_type(expected_type, val, prop_name)
+      end
+    end
+
+    def nil_optional_hash?(expected, hash)
+      expected.is_a?(Airborne::OptionalHashTypeExpectations) && hash.nil?
+    end
+
+    def hash?(hash)
+      hash.is_a?(Hash) || hash.is_a?(Airborne::OptionalHashTypeExpectations)
+    end
+
+    def expect_array(value, 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 convert_expectations_for_json_sizes(old_expectations)
+      unless old_expectations.is_a?(Hash)
+        return convert_expectation_for_json_sizes(old_expectations)
+      end
+
+      old_expectations.each_with_object({}) do |(prop_name, expected_size), memo|
+        new_value = if expected_size.is_a?(Hash)
+                      convert_expectations_for_json_sizes(expected_size)
+                    else
+                      convert_expectation_for_json_sizes(expected_size)
+                    end
+        memo[prop_name] = new_value
+      end
+    end
+
+    def convert_expectation_for_json_sizes(expected_size)
+      ->(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?(expectation)
+      [String, Regexp, Float, Integer, TrueClass, FalseClass, NilClass, Array].any?{|type| expectation.is_a?(type)}
+    end
+
+    def get_mapper
+      base_mapper = {
+        integer: [Integer],
+        array_of_integers: [Integer],
+        int: [Integer],
+        array_of_ints: [Integer],
+        float: [Float, Integer],
+        array_of_floats: [Float, Integer],
+        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
+      when String then candidate.to_s
+      when Integer then candidate.to_i
+      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/lib/airborne/rest_client_requester.rb

@@ -0,0 +1,33 @@
+require 'rest_client'
+
+module Airborne
+  module RestClientRequester
+    def make_request(method, url, options = {})
+      headers = base_headers.merge(options[: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::Request.execute(:method => method, :url => get_url(url), :payload => request_body, 
+                                      :headers => headers , :verify_ssl => Airborne.configuration.verify_ssl)
+        rescue RestClient::Exception => e
+          e.response
+        end
+      else
+        begin
+          RestClient::Request.execute(:method => method, :url => get_url(url), :headers => headers,
+                                      :verify_ssl => Airborne.configuration.verify_ssl)
+        rescue RestClient::Exception => e
+          e.response
+        end
+      end
+      res
+    end
+
+    private
+
+    def base_headers
+      { content_type: :json }.merge(Airborne.configuration.headers || {})
+    end
+  end
+end

data/lib/airborne.rb

@@ -0,0 +1,29 @@
+require 'airborne/optional_hash_type_expectations'
+require 'airborne/path_matcher'
+require 'airborne/request_expectations'
+require 'airborne/rest_client_requester'
+require 'airborne/rack_test_requester'
+require 'airborne/base'
+require 'openssl'
+
+RSpec.configure do |config|
+  config.add_setting :base_url
+  config.add_setting :verify_ssl, default: OpenSSL::SSL::VERIFY_NONE
+  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
+
+  # Include last since it depends on the configuration already being added
+  config.include Airborne
+end

data/spec/airborne/base_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe 'base spec' do
+  it 'when request is made response should be set' do
+    mock_get('simple_get')
+    get '/simple_get'
+    expect(response).to_not be(nil)
+  end
+
+  it 'when request is made headers should be set' do
+    mock_get('simple_get')
+    get '/simple_get'
+    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('invalid1234')
+    expect { json_body }.to raise_error(InvalidJsonError)
+  end
+
+  it 'when request is made headers should be hash with indifferent access' do
+    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
+
+  it 'when request is made body should be set' do
+    mock_get('simple_get')
+    get '/simple_get'
+    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)
+  end
+
+  it 'should handle a 500 error on get' do
+    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'])
+    post '/simple_post', {}
+    expect(json_body).to_not be(nil)
+  end
+end

data/spec/airborne/client_requester_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'openssl'
+
+describe 'client requester' do
+  before do
+    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 =  {} }
+  end
+
+  it 'should set :content_type to :json 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 => OpenSSL::SSL::VERIFY_NONE)
+  end
+
+  it 'should override headers with option[:headers]' do
+    get '/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 => OpenSSL::SSL::VERIFY_NONE)
+  end
+
+  it 'should override headers with airborne config headers' do
+    Airborne.configure { |config| config.headers = { content_type: 'text/plain' } }
+
+    get '/foo'
+
+    expect(RestClient::Request).to have_received(:execute)
+                            .with(:method => :get, :url => 'http://www.example.com/foo', 
+                            :headers => { content_type: 'text/plain' },
+                            :verify_ssl => OpenSSL::SSL::VERIFY_NONE)
+  end
+end

data/spec/airborne/delete_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'delete' do
+  it 'should allow testing on delete requests' do
+    mock_delete 'simple_delete'
+    delete '/simple_delete', {}
+    expect_status 200
+  end
+end

data/spec/airborne/expectations/expect_header_contains_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'expect header contains' do
+  it 'should ensure partial header match exists' do
+    mock_get('simple_get', 'Content-Type' => 'application/json')
+    get '/simple_get'
+    expect_header_contains(:content_type, 'json')
+  end
+
+  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(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(ExpectationNotMetError)
+  end
+end

data/spec/airborne/expectations/expect_header_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'expect header' do
+  it 'should find exact match for header content' do
+    mock_get('simple_get', 'Content-Type' => 'application/json')
+    get '/simple_get'
+    expect_header(:content_type, 'application/json')
+  end
+
+  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(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(ExpectationNotMetError)
+  end
+end

data/spec/airborne/expectations/expect_json_keys_path_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe 'expect_json_keys with path' do
+  it 'should ensure json keys with path' do
+    mock_get('simple_nested_path')
+    get '/simple_nested_path', {}
+    expect_json_keys('address', [:street, :city])
+  end
+
+  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(ExpectationNotMetError)
+  end
+end

data/spec/airborne/expectations/expect_json_keys_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+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(ExpectationNotMetError)
+  end
+
+  it 'should ensure correct json keys' do
+    mock_get('simple_json')
+    get '/simple_json', {}
+    expect_json_keys([:foo, :bar, :baz])
+  end
+
+  it 'should ensure correct partial json keys' do
+    mock_get('simple_json')
+    get '/simple_json', {}
+    expect_json_keys([:foo, :bar])
+  end
+end

data/spec/airborne/expectations/expect_json_lambda_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'expect_json lambda' do
+  it 'should invoke proc passed in' do
+    mock_get('simple_get')
+    get '/simple_get'
+    expect_json(name: ->(name) { expect(name.length).to eq(4) })
+  end
+end