api-validator 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in api-validator.gemspec
+gemspec
+
+gem 'json-pointer', :git => 'git://github.com/tent/json-pointer-ruby.git', :branch => 'master'

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2013 Apollic Software, LLC. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Apollic Software, LLC nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,80 @@
+# ApiValidator [![Build Status](https://travis-ci.org/tent/api-validator.png)](https://travis-ci.org/tent/api-validator)
+
+Framework for integration testing an API server.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'api-validator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install api-validator
+
+## Usage
+
+```ruby
+class MyValidation < ApiValidator::Spec
+
+  def create_resource
+    # ...
+    set(:resource, data)
+  end
+
+  def fudge_resource
+    # ...
+    set(:resource, fudged_data)
+  end
+
+  describe "GET /posts/{entity}/{id}" do
+    shared_examples :not_found do
+      expect_response(:schema => :error, :status => 404) do
+        # ...
+        response
+      end
+    end
+
+    context "when resource exists", :before => :create_resource do
+      context "when authorized to read all posts" do
+        authorize!(:server => :remote, :scopes => %w[ read_posts ], :read_types => %w[ all ])
+
+        expect_response(:schema => :post, :status => 200) do
+          expect_headers({ 'Content-Type' => /json\b/ })
+          expect_properties(:entity => get(:resource, :entity), :id => get(:resource, :id))
+          expect_schema(:post_content, "/content")
+
+          # ...
+          response
+        end
+      end
+
+      context "when authorize to write resource but not read" do
+        authorize!(:server => :remote, :scopes => %w[ write_posts ], :write_types => %w[ all ])
+        behaves_as :not_found
+      end
+
+      context "when not authorized" do
+        behaves_as :not_found
+      end
+    end
+
+    context "when resource does not exist", :before => :fudge_resource do
+      behaves_as :not_found
+    end
+  end
+
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+task :default => :spec

data/api-validator.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'api-validator/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "api-validator"
+  gem.version       = ApiValidator::VERSION
+  gem.authors       = ["Jesse Stuart"]
+  gem.email         = ["jesse@jessestuart.ca"]
+  gem.description   = %q{ }
+  gem.summary       = %q{ }
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency 'json-pointer'
+
+  gem.add_development_dependency 'rspec', '~> 2.11'
+  gem.add_development_dependency 'mocha', '~> 0.13'
+  gem.add_development_dependency "bundler", "~> 1.3"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "faraday"
+end

data/lib/api-validator.rb

@@ -0,0 +1,19 @@
+require 'api-validator/version'
+
+module ApiValidator
+
+  require 'api-validator/mixins'
+
+  require 'api-validator/assertion'
+  require 'api-validator/base'
+  require 'api-validator/json_schemas'
+  require 'api-validator/json_schema'
+  require 'api-validator/json'
+  require 'api-validator/json'
+  require 'api-validator/header'
+  require 'api-validator/status'
+
+  require 'api-validator/response_expectation'
+  require 'api-validator/spec'
+
+end

data/lib/api-validator/assertion.rb

@@ -0,0 +1,32 @@
+
+module ApiValidator
+  class Assertion
+
+    attr_reader :value, :path, :type, :format
+    def initialize(path, value, options = {})
+      @path, @value, @type, @format = path, value, options.delete(:type), options.delete(:format)
+    end
+
+    def to_hash(options = {})
+      _h = { :op => "test", :path => path, :value => stringified_value }
+      _h.delete(:value) if type && value.nil?
+      _h[:type] = "regexp" if Regexp === value
+      _h[:type] = type if type
+      _h[:format] = format if format
+      _h
+    end
+
+    def stringified_value
+      if Regexp === value
+        regex = value.to_s.
+          sub(%r|\(\?-mix:(.*)\)|) { $1 }.
+          gsub("\\A", "^").
+          gsub("\\Z", "$")
+        "/#{regex}/"
+      else
+        value
+      end
+    end
+
+  end
+end

data/lib/api-validator/base.rb

@@ -0,0 +1,47 @@
+require 'uri'
+
+module ApiValidator
+  class Base
+
+    def initialize(expected)
+      @expected = expected
+      initialize_assertions(expected)
+    end
+
+    def assertions
+      @assertions ||= []
+    end
+
+    def validate(response)
+      {
+        :assertions => assertions.map(&:to_hash)
+      }
+    end
+
+    private
+
+    def assertion_valid?(assertion, actual)
+      value = assertion.value
+      case value
+      when Regexp
+        value.match(actual.to_s)
+      when Numeric
+        (Numeric === actual) && (value == actual)
+      else
+        value == actual
+      end
+    end
+
+    def assertion_format_valid?(assertion, actual)
+      return true unless format = assertion.format
+      case format
+      when 'uri'
+        uri = URI(actual)
+        uri.scheme && uri.host
+      end
+    rescue URI::InvalidURIError, ArgumentError
+      false
+    end
+
+  end
+end

data/lib/api-validator/header.rb

@@ -0,0 +1,77 @@
+module ApiValidator
+  class Header < Base
+
+    def self.named_expectations
+      @named_expectations ||= {}
+    end
+
+    def self.register(name, expected)
+      named_expectations[name] = expected
+    end
+
+    def validate(response)
+      compiled_assertions = compile_assertions(response)
+      response_headers = response.env[:response_headers]
+      _failed_assertions = failed_assertions(compiled_assertions, response_headers)
+      super.merge(
+        :assertions => compiled_assertions.map(&:to_hash),
+        :key => :response_headers,
+        :failed_assertions => _failed_assertions.map(&:to_hash),
+        :diff => diff(response_headers, _failed_assertions).map(&:to_hash),
+        :valid => _failed_assertions.empty?
+      )
+    end
+
+    private
+
+    NoSuchExpectationError = Class.new(StandardError)
+    def initialize_assertions(expected)
+      unless Hash === expected
+        name = expected
+        unless expected = self.class.named_expectations[name]
+          raise NoSuchExpectationError.new("Expected #{name.inspect} to be registered with #{self.class.name}!")
+        end
+      end
+
+      @assertions = expected.inject([]) do |memo, (header, value)|
+        memo << Assertion.new("/#{header}", value)
+      end
+    end
+
+    def compile_assertions(response)
+      assertions.map do |assertion|
+        if Proc === assertion.value
+          Assertion.new(assertion.path, assertion.value.call(response))
+        else
+          assertion
+        end
+      end
+    end
+
+    def failed_assertions(assertions, actual)
+      assertions.select do |assertion|
+        header = key_from_path(assertion.path)
+        !assertion_valid?(assertion, actual[header])
+      end
+    end
+
+    def diff(actual, _failed_assertions)
+      _failed_assertions.map do |assertion|
+        header = key_from_path(assertion.path)
+        assertion = assertion.to_hash
+        if actual.has_key?(header)
+          assertion[:op] = "replace"
+          assertion[:current_value] = actual[header]
+        else
+          assertion[:op] = "add"
+        end
+        assertion
+      end
+    end
+
+    def key_from_path(path)
+      path.slice(1, path.length) # remove prefixed "/"
+    end
+
+  end
+end

data/lib/api-validator/json.rb

@@ -0,0 +1,56 @@
+module ApiValidator
+  class Json < Base
+
+    def validate(response)
+      response_body = response.body.respond_to?(:to_hash) ? response.body.to_hash : response.body
+      _failed_assertions = failed_assertions(response_body)
+      super.merge(
+        :key => :response_body,
+        :failed_assertions => _failed_assertions.map(&:to_hash),
+        :diff => diff(response_body, _failed_assertions),
+        :valid => _failed_assertions.empty?
+      )
+    end
+
+    private
+
+    def initialize_assertions(expected, path = "")
+      case expected
+      when Hash
+        expected.each_pair do |key, val|
+          item_path = [path, key].join("/")
+          initialize_assertions(val, item_path)
+        end
+      when Array
+        expected.each_with_index do |val, index|
+          item_path = [path, index].join("/")
+          initialize_assertions(val, item_path)
+        end
+      else
+        assertions << Assertion.new(path, expected)
+      end
+    end
+
+    def failed_assertions(actual)
+      assertions.select do |assertion|
+        pointer = JsonPointer.new(actual, assertion.path)
+        !pointer.exists? || !assertion_valid?(assertion, pointer.value)
+      end
+    end
+
+    def diff(actual, _failed_assertions)
+      _failed_assertions.map do |assertion|
+        pointer = JsonPointer.new(actual, assertion.path)
+        assertion = assertion.to_hash
+        if pointer.exists?
+          assertion[:op] = "replace"
+          assertion[:current_value] = pointer.value
+        else
+          assertion[:op] = "add"
+        end
+        assertion
+      end
+    end
+
+  end
+end

data/lib/api-validator/json_schema.rb

@@ -0,0 +1,228 @@
+require 'json-pointer'
+
+module ApiValidator
+  class JsonSchema < Base
+
+    SchemaNotFoundError = Class.new(StandardError)
+
+    attr_reader :root_path
+    def initialize(expected, root_path = nil)
+      @expected, @root_path = expected, root_path
+
+      if Hash === expected
+        schema = expected
+      else
+        unless schema = JsonSchemas[expected]
+          raise SchemaNotFoundError.new("Unable to locate schema: #{expected.inspect}")
+        end
+      end
+
+      @schema = schema
+
+      initialize_assertions(schema)
+    end
+
+    def validate(response)
+      response_body = response.body.respond_to?(:to_hash) ? response.body.to_hash : response.body
+      _failed_assertions = failed_assertions(response_body)
+      _diff = diff(response_body, _failed_assertions)
+      super.merge(
+        :key => :response_body,
+        :failed_assertions => _failed_assertions.map(&:to_hash),
+        :diff => _diff,
+        :valid => _diff.empty?
+      )
+    end
+
+    def initialize_assertions(schema, parent_path = "")
+      parent_path = root_path if root_path && parent_path == ""
+      (schema["properties"] || {}).each_pair do |key, val|
+        next unless val["required"] == true
+        path = [parent_path, key].join("/")
+        assertions << Assertion.new(path, nil, :type => val["type"])
+        if val["type"] == "object"
+          initialize_assertions(val, path)
+        end
+      end
+    end
+
+    def failed_assertions(actual)
+      assertions.select do |assertion|
+        pointer = JsonPointer.new(actual, assertion.path)
+        !pointer.exists? || !assertion_valid?(assertion, pointer.value)
+      end
+    end
+
+    def diff(actual, _failed_assertions)
+      _diff = _failed_assertions.inject([]) do |memo, assertion|
+        pointer = JsonPointer.new(actual, assertion.path)
+        if !pointer.exists?
+          assertion = assertion.to_hash
+          actual_value = nil
+          assertion[:op] = "add"
+          assertion[:value] = value_for_schema_type(assertion[:type], actual_value)
+          assertion[:message] = wrong_type_message(assertion[:type], schema_type(actual_value))
+          memo << assertion
+        end
+        memo
+      end
+
+      _diff + schema_diff(@schema, actual)
+    end
+
+    def schema_diff(schema, actual, parent_path = "")
+      properties = schema["properties"]
+
+      return [] unless Hash === actual
+
+      if root_path && parent_path == ""
+        pointer = JsonPointer.new(actual, root_path)
+        return [] unless pointer.exists?
+        actual = pointer.value
+
+        parent_path = root_path
+      end
+
+      actual.inject([]) do |memo, (key, val)|
+        path = [parent_path, key].join("/")
+        if property = properties[key.to_s]
+          schema_property_diff(property, val, path) do |diff_item|
+            memo << diff_item
+          end
+        elsif schema['additionalProperties'] == false
+          memo << { :op => "remove", :path => path }
+        end
+        memo
+      end
+    end
+
+    def schema_property_diff(property, actual, path, &block)
+      assertion = Assertion.new(path, nil, :type => property["type"], :format => property["format"])
+
+      if !assertion_valid?(assertion, actual)
+        yield({
+          :op => "replace",
+          :path => path,
+          :value => value_for_schema_type(assertion.type, actual),
+          :current_value => actual,
+          :type => assertion.type,
+          :message => wrong_type_message(assertion.type, schema_type(actual))
+        })
+      elsif !assertion_format_valid?(assertion, actual)
+        yield({
+          :op => "replace",
+          :path => path,
+          :value => value_for_schema_format(assertion.format, actual),
+          :current_value => actual,
+          :type => assertion.type,
+          :format => assertion.format,
+          :message => wrong_format_message(assertion.format)
+        })
+      elsif (property["type"] == "object") && (Hash === property["properties"])
+        schema_diff(property, actual, path).each { |d| yield(d) }
+      elsif (property['type'] == 'array') && (Hash === property['items'])
+        array_property = property['items']
+        actual.each_with_index do |val, index|
+          schema_property_diff(array_property, val, path + "/#{index}", &block)
+        end
+      end
+    end
+
+    def wrong_type_message(expected_type, actual_type)
+      "expected type #{expected_type}, got #{actual_type}"
+    end
+
+    def wrong_format_message(expected_format)
+      "expected #{expected_format} format"
+    end
+
+    def assertion_valid?(assertion, actual)
+      type = assertion.type
+      case type
+      when "array"
+        Array === actual
+      when "boolean"
+        (TrueClass === actual) || (FalseClass === actual)
+      when "integer"
+        Fixnum === actual
+      when "number"
+        Numeric === actual
+      when "null"
+        NilClass === actual
+      when "object"
+        Hash === actual
+      when "string"
+        String === actual
+      else
+        super
+      end
+    end
+
+    def schema_type(value)
+      case value
+      when Array
+        "array"
+      when TrueClass, FalseClass
+        "boolean"
+      when Fixnum
+        "integer"
+      when Numeric
+        "number"
+      when NilClass
+        "null"
+      when Hash
+        "object"
+      when String
+        "string"
+      else
+        "unknown"
+      end
+    end
+
+    def value_for_schema_type(type, value)
+      klass = class_for_schema_type(type)
+      if klass == Array
+        value.respond_to?(:to_a) ? value.to_a : Array.new
+      elsif klass == [TrueClass, FalseClass]
+        !!value
+      elsif klass == Fixnum
+        value.respond_to?(:to_i) ? value.to_i : 0
+      elsif klass == Numeric
+        value.respond_to?(:to_f) ? value.to_f : 0.0
+      elsif klass == Hash
+        value.respond_to?(:to_hash) ? value.to_hash : Hash.new
+      elsif klass == String
+        value.respond_to?(:to_s) ? value.to_s : ""
+      else
+        nil
+      end
+    end
+
+    def value_for_schema_format(format, value)
+      case format
+      when 'uri'
+        "https://example.com"
+      end
+    end
+
+    def class_for_schema_type(type)
+      case type
+      when "array"
+        Array
+      when "boolean"
+        [TrueClass, FalseClass]
+      when "integer"
+        Fixnum
+      when "number"
+        Numeric
+      when "null"
+        NilClass
+      when "object"
+        Hash
+      when "string"
+        String
+      end
+    end
+
+  end
+end