api-validator 0.0.1

data/lib/api-validator/json_schemas.rb

@@ -0,0 +1,20 @@
+module ApiValidator
+  class JsonSchemas
+
+    def self.register(schema_name, schema)
+      schemas[schema_name.to_s] = schema
+    end
+    class << self
+      alias []= register
+    end
+
+    def self.schemas
+      @schemas ||= {}
+    end
+
+    def self.[](schema_name)
+      schemas[schema_name.to_s]
+    end
+
+  end
+end

data/lib/api-validator/mixins.rb

@@ -0,0 +1,7 @@
+module ApiValidator
+  module Mixins
+
+    require 'api-validator/mixins/deep_merge'
+
+  end
+end

data/lib/api-validator/mixins/deep_merge.rb

@@ -0,0 +1,28 @@
+module ApiValidator
+  module Mixins
+
+    module DeepMerge
+      def deep_merge!(hash, *others)
+        others.each do |other|
+          other.each_pair do |key, val|
+            if hash.has_key?(key)
+              next if hash[key] == val
+              case val
+              when Hash
+                deep_merge!(hash[key], val)
+              when Array
+                hash[key].concat(val)
+              when FalseClass
+                # false always wins
+                hash[key] = val
+              end
+            else
+              hash[key] = val
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/api-validator/response_expectation.rb

@@ -0,0 +1,90 @@
+module ApiValidator
+  class ResponseExpectation
+
+    require 'api-validator/response_expectation/results'
+
+    attr_accessor :status_validator
+    def initialize(validator, options = {}, &block)
+      @validator, @block = validator, block
+      initialize_headers(options.delete(:headers))
+      initialize_status(options.delete(:status))
+      initialize_schema(options.delete(:schema))
+    end
+
+    def initialize_headers(expected_headers)
+      return unless expected_headers
+      self.header_validators << ApiValidator::Header.new(expected_headers)
+    end
+
+    def initialize_status(expected_status)
+      return unless expected_status
+      self.status_validator = ApiValidator::Status.new(expected_status)
+    end
+
+    def initialize_schema(expected_schema)
+      return unless expected_schema
+      schema_validators << ApiValidator::JsonSchema.new(expected_schema)
+    end
+
+    def json_validators
+      @json_validators ||= []
+    end
+
+    def schema_validators
+      @schema_validators ||= []
+    end
+
+    def header_validators
+      @header_validators ||= []
+    end
+
+    def response_filters
+      @response_filters ||= []
+    end
+
+    def expectations
+      [status_validator].compact + header_validators + schema_validators + json_validators
+    end
+
+    def expect_properties(properties)
+      json_validators << ApiValidator::Json.new(properties)
+    end
+
+    def expect_schema(expected_schema, path=nil)
+      schema_validators << ApiValidator::JsonSchema.new(expected_schema, path)
+    end
+
+    def expect_headers(expected_headers)
+      header_validators << ApiValidator::Header.new(expected_headers)
+    end
+
+    def expect_post_type(type_uri)
+      response_filters << proc { |response| response.env['expected_post_type'] = type_uri }
+      type_uri
+    end
+
+    def run
+      return unless @block
+      response = instance_eval(&@block)
+      Results.new(response, validate(response))
+    end
+
+    def validate(response)
+      response_filters.each { |filter| filter.call(response) }
+      expectations.map { |expectation| expectation.validate(response) }
+    end
+
+    def respond_to_method_missing?(method)
+      @validator.respond_to?(method)
+    end
+
+    def method_missing(method, *args, &block)
+      if respond_to_method_missing?(method)
+        @validator.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/api-validator/response_expectation/results.rb

@@ -0,0 +1,62 @@
+module ApiValidator
+  class ResponseExpectation
+
+    class Results
+      include Mixins::DeepMerge
+
+      attr_reader :response, :results
+      def initialize(response, results)
+        @response, @results = response, results
+      end
+
+      def as_json(options = {})
+        res = results.inject(Hash.new) do |memo, result|
+          result = result.dup
+          deep_merge!((memo[result.delete(:key)] ||= Hash.new), result)
+          memo
+        end
+
+        merge_diffs!(res)
+
+        {
+          :expected => res,
+          :actual => {
+            :request_headers => response.env[:request_headers],
+            :request_body => response.env[:request_body],
+            :request_path => response.env[:url].path,
+            :request_params => parse_params(response.env[:url]),
+            :request_url => response.env[:url].to_s,
+            :request_method => response.env[:method].to_s.upcase,
+
+            :response_headers => response.headers,
+            :response_body => response.body,
+            :response_status => response.status
+          }
+        }
+      end
+
+      private
+
+      def parse_params(uri)
+        return unless uri.query
+        uri.query.split('&').inject({}) do |params, part|
+          key, value = part.split('=')
+          params[key] = value
+          params
+        end
+      end
+
+      def merge_diffs!(expectation_results)
+        expectation_results.each_pair do |key, results|
+          results[:diff] = results[:diff].inject({}) do |memo, diff|
+            (memo[diff[:path]] ||= []) << diff
+            memo
+          end.inject([]) do |memo, (path, diffs)|
+            memo << diffs.sort_by { |d| d[:value].to_s.size * -1 }.first
+          end.sort_by { |d| d[:path].split("/").size }
+        end
+      end
+    end
+
+  end
+end

data/lib/api-validator/spec.rb

@@ -0,0 +1,153 @@
+module ApiValidator
+  class Spec
+
+    require 'api-validator/spec/results'
+
+    module SharedClassAndInstanceMethods
+      def shared_examples
+        @shared_examples ||= begin
+          if self.respond_to?(:superclass) && self.superclass.respond_to?(:shared_examples)
+            self.superclass.shared_examples || Hash.new
+          else
+            Hash.new
+          end
+        end
+      end
+
+      def shared_example(name, &block)
+        self.shared_examples[name] = block
+      end
+
+      def validations
+        @validations ||= []
+      end
+
+      def describe(name, options = {}, &block)
+        validation = self.new(name, options.merge(:parent => self), &block)
+        self.validations << validation
+        validation
+      end
+      alias context describe
+    end
+
+    class << self
+      include SharedClassAndInstanceMethods
+    end
+    include SharedClassAndInstanceMethods
+
+    def self.run
+      validations.inject(Results.new(self.new(''), [])) do |memo, validation|
+        results = validation.run
+        memo.merge!(results)
+      end
+    end
+
+    attr_reader :parent, :name, :pending
+    def initialize(name, options = {}, &block)
+      @parent = options.delete(:parent)
+      @parent = nil if @parent == self.class
+      @name = name
+
+      initialize_before_hooks(options.delete(:before))
+
+      if block_given?
+        instance_eval(&block)
+      else
+        @pending = true
+      end
+    end
+
+    def initialize_before_hooks(hooks)
+      Array(hooks).each do |method_name_or_block|
+        if method_name_or_block.respond_to?(:call)
+          self.before_hooks << method_name_or_block
+        elsif respond_to?(method_name_or_block)
+          self.before_hooks << method(method_name_or_block)
+        end
+      end
+    end
+
+    def before_hooks
+      @before_hooks ||= []
+    end
+
+    def new(*args, &block)
+      self.class.new(*args, &block)
+    end
+
+    def find_shared_example(name)
+      ref = self
+      begin
+        if block = ref.shared_examples[name]
+          return block
+        end
+      end while ref = ref.parent
+      self.class.shared_examples[name]
+    end
+
+    BehaviourNotFoundError = Class.new(StandardError)
+    def behaves_as(name)
+      block = find_shared_example(name)
+      raise BehaviourNotFoundError.new("Behaviour #{name.inspect} could not be found") unless block
+      instance_eval(&block)
+    end
+
+    def expectations
+      @expectations ||= []
+    end
+
+    def expect_response(options = {}, &block)
+      expectation = ResponseExpectation.new(self, options, &block)
+      self.expectations << expectation
+      expectation
+    end
+
+    def cache
+      @cache ||= Hash.new
+    end
+
+    def get(path)
+      if Symbol === path
+        path = "/#{path}"
+      end
+
+      pointer = JsonPointer.new(cache, path, :symbolize_keys => true)
+      unless pointer.exists?
+        return parent ? parent.get(path) : nil
+      end
+      val = pointer.value
+      Proc === val ? val.call : val
+    end
+
+    def set(path, val=nil, &block)
+      if Symbol === path
+        path = "/#{path}"
+      end
+
+      pointer = JsonPointer.new(cache, path, :symbolize_keys => true)
+      pointer.value = block_given? ? block : val
+      val
+    end
+
+    def run
+      before_hooks.each do |hook|
+        if hook.respond_to?(:receiver) && hook.receiver == self
+          # It's a method
+          hook.call
+        else
+          # It's a block
+          instance_eval(&hook)
+        end
+      end
+
+      results = self.expectations.inject([]) do |memo, expectation|
+        memo << expectation.run
+      end
+
+      self.validations.inject(Results.new(self, results)) do |memo, validation|
+        memo.merge!(validation.run)
+      end
+    end
+
+  end
+end

data/lib/api-validator/spec/results.rb

@@ -0,0 +1,28 @@
+module ApiValidator
+  class Spec
+
+    class Results
+      include Mixins::DeepMerge
+
+      attr_reader :name, :results
+      def initialize(validator, expectations_results)
+        @name = validator.name
+        @results = {
+          @name => {
+            :results => expectations_results
+          }
+        }
+      end
+
+      def merge!(other)
+        deep_merge!(results[name], other.results)
+        self
+      end
+
+      def as_json(options = {})
+        results
+      end
+    end
+
+  end
+end

data/lib/api-validator/status.rb

@@ -0,0 +1,37 @@
+module ApiValidator
+  class Status < Base
+
+    def validate(response)
+      response_status = response.status
+      _failed_assertions = failed_assertions(response_status)
+      super.merge(
+        :key => :response_status,
+        :failed_assertions => _failed_assertions.map(&:to_hash),
+        :diff => diff(response_status, _failed_assertions),
+        :valid => _failed_assertions.empty?
+      )
+    end
+
+    private
+
+    def initialize_assertions(expected)
+      @assertions = [ Assertion.new("", expected) ]
+    end
+
+    def failed_assertions(actual)
+      assertions.select do |assertion|
+        !assertion_valid?(assertion, actual)
+      end
+    end
+
+    def diff(actual, _failed_assertions)
+      _failed_assertions.map do |assertion|
+        assertion = assertion.to_hash
+        assertion[:op] = "replace"
+        assertion[:current_value] = actual
+        assertion
+      end
+    end
+
+  end
+end

data/lib/api-validator/version.rb

@@ -0,0 +1,3 @@
+module ApiValidator
+  VERSION = "0.0.1"
+end

data/spec/header_validator_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+require 'faraday'
+
+require 'support/validator_shared_examples'
+
+describe ApiValidator::Header do
+  let(:env) { HashWrapper.new(:status => 200, :response_headers => {}, :token => 'foobar', :body => '') }
+  let(:response) { Faraday::Response.new(env) }
+  let(:validator) { stub(:everything) }
+  let(:instance) { described_class.new(expected) }
+  let(:expectation_key) { :response_headers }
+
+  let(:res) { instance.validate(response) }
+
+  describe "#validate" do
+    let(:expected) do
+      {
+        "Count" => /\A\d+\Z/,
+        "Token" => lambda { |response| response.env['token'] },
+        "Say Hello" => "Hello Tent!"
+      }
+    end
+
+    let(:expected_assertions) {
+      [
+        { :op => "test", :path => "/Count", :value => "/^\\d+$/", :type => "regexp" },
+        { :op => "test", :path => "/Token", :value => env[:token] },
+        { :op => "test", :path => "/Say Hello", :value => "Hello Tent!" }
+      ]
+    }
+
+    context "when expectation fails" do
+      context "when expectation is a Regexp" do
+        it_behaves_like "a validator #validate method"
+
+        before do
+          env.response_headers = {
+            "Count" => "NaN",
+            "Token" => env[:token],
+            "Say Hello" => "Hello Tent!"
+          }
+        end
+
+        let(:expected_diff) { [{ :op => "replace", :path => "/Count", :value => "/^\\d+$/", :current_value => "NaN", :type => "regexp" }] }
+        let(:expected_failed_assertions) { [expected_assertions.first] }
+      end
+
+      context "when expectation is a lambda" do
+        it_behaves_like "a validator #validate method"
+
+        before do
+          env.response_headers = {
+            "Count" => "185",
+            "Token" => "baz",
+            "Say Hello" => "Hello Tent!"
+          }
+        end
+
+        let(:expected_diff) { [{ :op => "replace", :path => "/Token", :value => env[:token], :current_value => "baz" }] }
+        let(:expected_failed_assertions) { [expected_assertions[1]] }
+      end
+
+      context "when expectation is a String" do
+        it_behaves_like "a validator #validate method"
+
+        before do
+          env.response_headers = {
+            "Count" => "185",
+            "Token" => env[:token],
+            "Say Hello" => "No, I won't do it!"
+          }
+        end
+
+        let(:expected_diff) { [{ :op => "replace", :path => "/Say Hello", :value => "Hello Tent!", :current_value => "No, I won't do it!" }] }
+        let(:expected_failed_assertions) { [expected_assertions.last] }
+      end
+
+      context "when header missing" do
+        it_behaves_like "a validator #validate method"
+
+        before do
+          env.response_headers = {
+            "Count" => "185",
+            "Token" => env[:token]
+          }
+        end
+
+        let(:expected_diff) { [{ :op => "add", :path => "/Say Hello", :value => "Hello Tent!" }] }
+        let(:expected_failed_assertions) { [expected_assertions.last] }
+      end
+    end
+
+    context "when expectation passes" do
+      it_behaves_like "a validator #validate method"
+
+      before do
+        env.response_headers = {
+          "Count" => "198",
+          "Token" => env[:token],
+          "Say Hello" => "Hello Tent!"
+        }
+      end
+
+      let(:expected_diff) { [] }
+      let(:expected_failed_assertions) { [] }
+    end
+  end
+end