mini-apivore 0.1.0

data/lib/mini_apivore.rb

@@ -0,0 +1,74 @@
+require 'json-schema'
+require 'mini_apivore/version'
+require 'mini_apivore/fragment'
+require 'mini_apivore/swagger'
+require 'mini_apivore/swagger_checker'
+require 'mini_apivore/validation'
+require 'mini_apivore/http_codes'
+
+module MiniApivore
+  SWAGGER_CHECKERS = {}
+  #----- Module globals -----------------
+  def self.runnable_list; @@runnable_list ||= []  end
+  def self.all_test_ran?; runnable_list.empty? end
+
+  def self.prepare_untested_errors
+    errors = []
+    SWAGGER_CHECKERS.each do |cls, chkr|
+      chkr.untested_mappings.each do |path, methods|
+        methods.each do |method, codes|
+          codes.each do |code, _|
+            errors << "#{method} #{path} is untested for response code #{code} in test class #{cls.to_s}"
+          end
+        end
+      end
+    end
+    errors
+  end
+
+  def self.included(base)
+    base.extend ClassMethods
+    base.include MiniApivore::Validation
+  end
+
+  #---- class methods -----------
+  module ClassMethods
+
+    def init_swagger( swagger_path )
+      SWAGGER_CHECKERS[self] ||= MiniApivore::SwaggerChecker.instance_for(swagger_path)
+    end
+
+    def runnable_methods
+      super | ['final_test']
+    end
+
+    def test(name, &block )
+      super( name, &block ).tap{ |sym| MiniApivore.runnable_list << "#{to_s}::#{sym}" }
+    end
+
+    def swagger_checker;
+      SWAGGER_CHECKERS[self]
+    end
+  end
+
+  #----- Minitest callback -----------
+  def teardown
+    super
+    MiniApivore.runnable_list.delete( "#{self.class.to_s}::#{@NAME}" )
+  end
+
+  #----- test for untested routes ---------
+  def final_test
+    return unless MiniApivore.all_test_ran?
+
+    @errors = MiniApivore.prepare_untested_errors
+    assert( @errors.empty?, @errors.join("\n") )
+
+    # preventing duplicate execution
+    MiniApivore.runnable_list << "#{self.class.to_s}::#{__method__}_runned"
+  end
+
+
+end
+
+

data/lib/mini_apivore/declarative.rb

@@ -0,0 +1,26 @@
+require "mini_apivore/version"
+
+module ActiveSupport
+  module Testing
+    module Declarative
+      # Helper to define a test method using a String. Under the hood, it replaces
+      # spaces with underscores and defines the test method.
+      #
+      #   test "verify something" do
+      #     ...
+      #   end
+      def test(name, &block)
+        test_name = "test_#{name.gsub(/\s+/, '_')}".to_sym
+        defined = method_defined? test_name
+        raise "#{test_name} is already defined in #{self}" if defined
+        if block_given?
+          define_method(test_name, &block)
+        else
+          define_method(test_name) do
+            flunk "No implementation provided for #{name}"
+          end
+        end
+      end
+    end
+  end
+end unless defined?(ActiveSupport)

data/lib/mini_apivore/fragment.rb

@@ -0,0 +1,11 @@
+require "mini_apivore/version"
+
+module MiniApivore
+  # This is a workaround for json-schema's fragment validation which does not allow paths to contain forward slashes
+  #  current json-schema attempts to split('/') on a string path to produce an array.
+  class Fragment < Array
+    def split(options = nil)
+      self
+    end
+  end
+end

data/lib/mini_apivore/http_codes.rb

@@ -0,0 +1,9 @@
+require "mini_apivore/version"
+
+module MiniApivore
+  NOT_FOUND = 404
+  NOT_AUTHORIZED = 401
+  FORBIDDEN = 403  # Access denied
+  UNPROCESSABLE_ENTITY = 422
+  OK = 200
+end

data/lib/mini_apivore/swagger.rb

@@ -0,0 +1,52 @@
+require "mini_apivore/version"
+require 'hashie'
+
+
+module MiniApivore
+  class Swagger < Hashie::Mash
+    NONVERB_PATH_ITEMS = %q(parameters)
+
+    def validate
+      case version
+        when '2.0'
+          schema = File.read(File.expand_path("../../../data/swagger_2.0_schema.json", __FILE__))
+        else
+          raise "Unknown/unsupported Swagger version to validate against: #{version}"
+      end
+      JSON::Validator.fully_validate(schema, self)
+    end
+
+    def version
+      swagger
+    end
+
+    def base_path
+      self['basePath'] || ''
+    end
+
+    def each_response(&block)
+      paths.each do |path, path_data|
+        next if vendor_specific_tag? path
+        path_data.each do |verb, method_data|
+          next if NONVERB_PATH_ITEMS.include?(verb)
+          next if vendor_specific_tag? verb
+          if method_data.responses.nil?
+            raise "No responses found in swagger for path '#{path}', " \
+              "verb #{verb}: #{method_data.inspect}"
+          end
+          method_data.responses.each do |response_code, response_data|
+            schema_location = nil
+            if response_data.schema
+              schema_location = Fragment.new ['#', 'paths', path, verb, 'responses', response_code, 'schema']
+            end
+            block.call(path, verb, response_code, schema_location)
+          end
+        end
+      end
+    end
+
+    def vendor_specific_tag? tag
+      tag =~ /\Ax-.*/
+    end
+  end
+end

data/lib/mini_apivore/swagger_checker.rb

@@ -0,0 +1,114 @@
+require "mini_apivore/version"
+
+module MiniApivore
+  class SwaggerChecker
+    PATH_TO_CHECKER_MAP = {}
+
+    def self.instance_for(path)
+      PATH_TO_CHECKER_MAP[path] ||= new(path)
+    end
+
+    def has_path?(path)
+      mappings.has_key?(path)
+    end
+
+    def has_method_at_path?(path, verb)
+      mappings[path].has_key?(verb)
+    end
+
+    def has_response_code_for_path?(path, verb, code)
+      mappings[path][verb].has_key?(code.to_s)
+    end
+
+    def response_codes_for_path(path, verb)
+      mappings[path][verb].keys.join(", ")
+    end
+
+    def has_matching_document_for(path, verb, code, body)
+      JSON::Validator.fully_validate(
+        swagger, body, fragment: fragment(path, verb, code)
+      )
+    end
+
+    def fragment(path, verb, code)
+      path_fragment = mappings[path][verb.to_s][code.to_s]
+      path_fragment.dup unless path_fragment.nil?
+    end
+
+    def remove_tested_end_point_response(path, verb, code)
+      return if untested_mappings[path].nil? ||
+        untested_mappings[path][verb].nil?
+      untested_mappings[path][verb].delete(code.to_s)
+      if untested_mappings[path][verb].size == 0
+        untested_mappings[path].delete(verb)
+        if untested_mappings[path].size == 0
+          untested_mappings.delete(path)
+        end
+      end
+    end
+
+    def base_path
+      @swagger.base_path
+    end
+
+    def response=(response)
+      @response = response
+    end
+
+    attr_reader :response, :swagger, :swagger_path
+
+    def untested_mappings; @untested_mappings end
+    def untested_mappings=( other ); @untested_mappings = other end
+
+    private
+
+    attr_reader :mappings
+
+    def initialize(swagger_path)
+      @swagger_path = swagger_path
+      load_swagger_doc!
+      validate_swagger!
+      setup_mappings!
+    end
+
+    # сюда можно поставить замену для загрузки из файла данных, а не из рельс.
+    def load_swagger_doc!
+      @swagger = MiniApivore::Swagger.new(fetch_swagger!)
+    end
+
+    def fetch_swagger!
+      if File.exist?( swagger_path )
+        JSON.parse( File.read(swagger_path) )
+      else
+        session = ActionDispatch::Integration::Session.new(Rails.application)
+        begin
+          session.get(swagger_path)
+        rescue
+          fail "Unable to perform GET request for swagger json: #{swagger_path} - #{$!}."
+        end
+        JSON.parse(session.response.body)
+      end
+    end
+
+    def validate_swagger!
+      errors = swagger.validate
+      unless errors.empty?
+        msg = "The document fails to validate as Swagger #{swagger.version}:\n"
+        msg += errors.join("\n")
+        fail msg
+      end
+    end
+
+    def setup_mappings!
+      @mappings = {}
+      @swagger.each_response do |path, verb, response_code, fragment|
+        @mappings[path] ||= {}
+        @mappings[path][verb] ||= {}
+        raise "duplicate" unless @mappings[path][verb][response_code].nil?
+        @mappings[path][verb][response_code] = fragment
+      end
+
+      self.untested_mappings = JSON.parse(JSON.generate(@mappings))
+    end
+  end
+end

data/lib/mini_apivore/validation.rb

@@ -0,0 +1,133 @@
+require "mini_apivore/version"
+
+module MiniApivore
+  module Validation # former Validator
+
+    class IndHash < Hash
+      include Hashie::Extensions::MergeInitializer
+      include Hashie::Extensions::IndifferentAccess
+    end
+
+    def prepare_action_env(verb, path, expected_response_code, params = {})
+      @errors = []
+      @verb = verb.to_s
+      @path = path.to_s
+      @params = IndHash.new(params)
+      @expected_response_code = expected_response_code.to_i
+    end
+
+    def swagger_checker; self.class.swagger_checker end
+
+    def check_route( verb, path, expected_response_code, params = {} )
+      prepare_action_env( verb, path, expected_response_code, params )
+      assert( match?, failure_message )
+    end
+
+    def match?
+      #pre_checks
+      check_request_path
+
+      # request
+      unless has_errors?
+        send(
+          @verb,
+          *action_dispatch_request_args(
+            full_path,
+            params: @params['_data'] || {},
+            headers: @params['_headers'] || {}
+          )
+        )
+
+        #post_checks
+        check_status_code
+        check_response_is_valid unless has_errors?
+
+
+        if has_errors? && response.body.length > 0
+          @errors << "\nResponse body:\n #{JSON.pretty_generate(JSON.parse(response.body))}"
+        end
+
+        swagger_checker.remove_tested_end_point_response(
+          @path, @verb, @expected_response_code
+        )
+      end
+      !has_errors?
+    end
+
+    def check_request_path
+      if !swagger_checker.has_path?(@path)
+        @errors << "Swagger doc: #{swagger_checker.swagger_path} does not have"\
+            " a documented @path for #{@path}"
+      elsif !swagger_checker.has_method_at_path?(@path, @verb)
+        @errors << "Swagger doc: #{swagger_checker.swagger_path} does not have"\
+            " a documented @path for #{@verb} #{@path}"
+      elsif !swagger_checker.has_response_code_for_path?(@path, @verb, @expected_response_code)
+        @errors << "Swagger doc: #{swagger_checker.swagger_path} does not have"\
+            " a documented response code of #{@expected_response_code} at @path"\
+            " #{@verb} #{@path}. "\
+            "\n             Available response codes: #{swagger_checker.response_codes_for_path(@path, @verb)}"
+      elsif @verb == "get" && swagger_checker.fragment(@path, @verb, @expected_response_code).nil?
+        @errors << "Swagger doc: #{swagger_checker.swagger_path} missing"\
+            " response model for get request with #{@path} for code"\
+            " #{@expected_response_code}"
+      end
+    end
+
+    def full_path
+      apivore_build_path(swagger_checker.base_path + @path, @params)
+    end
+
+    def apivore_build_path(path, data)
+      path.scan(/\{([^\}]*)\}/).each do |param|
+        key = param.first
+        dkey = data && ( data[key] || data[key.to_sym] )
+        if dkey
+          path = path.gsub "{#{key}}", dkey.to_s
+        else
+          raise URI::InvalidURIError, "No substitution data found for {#{key}}"\
+              " to test the path #{path}.", caller
+        end
+      end
+      path + (data['_query_string'] ? "?#{data['_query_string'].to_param}" : '')
+    end
+
+    def has_errors?; !@errors.empty?  end
+
+    def failure_message; @errors.join(" ") end
+
+    def check_status_code
+      if response.status != @expected_response_code
+        @errors << "Path #{@path} did not respond with expected status code."\
+            " Expected #{@expected_response_code} got #{response.status}"\
+        end
+    end
+
+    def check_response_is_valid
+      swagger_errors = swagger_checker.has_matching_document_for(
+        @path, @verb, response.status, response_body
+      )
+      unless swagger_errors.empty?
+        @errors.concat(
+          swagger_errors.map do |e|
+            e.sub("'#", "'#{full_path}#").gsub(
+              /^The property|in schema.*$/,''
+            )
+          end
+        )
+      end
+    end
+
+    def response_body
+      JSON.parse(response.body) if response.body && !response.body.empty?
+    end
+
+    def action_dispatch_request_args(path, params: {}, headers: {})
+      if defined?(ActionPack) && ActionPack::VERSION::MAJOR >= 5
+        [path, params: params, headers: headers]
+      else
+        [path, params, headers]
+      end
+    end
+  end
+
+end

data/lib/mini_apivore/version.rb

@@ -0,0 +1,5 @@
+module Mini
+  module Apivore
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: mini-apivore
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- alekseyl
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+description: " Provides a tool for testing your application api against your swagger
+  schema "
+email:
+- leshchuk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- data/draft04_schema.json
+- data/swagger_2.0_schema.json
+- lib/mini_apivore.rb
+- lib/mini_apivore/declarative.rb
+- lib/mini_apivore/fragment.rb
+- lib/mini_apivore/http_codes.rb
+- lib/mini_apivore/swagger.rb
+- lib/mini_apivore/swagger_checker.rb
+- lib/mini_apivore/validation.rb
+- lib/mini_apivore/version.rb
+homepage: https://github.com/alekseyl/mini-apivore
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- data
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Minitest adaptation of an apivore gem
+test_files: []