mini-apivore 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa9fdf04929ba14663fa747bff93b33d363fb8889b35f18c65670a4b71853aa7
-  data.tar.gz: 81b2366fe6a464587cc3c1f0fe35253d03a2e2a44fd08ec0577d36a44b5a9a15
+  metadata.gz: cd4021c1b59f97da6c130712948c65a271135cc50ebc8b38e438c9a39ea834b7
+  data.tar.gz: 96056ed390b669092813bd6bd7b5f9fa44485719ed1d7135234d690440848c13
 SHA512:
-  metadata.gz: 6c663d6d801e464d191e78dc86490239aa05a17f54975267f638e5125a02200f89f3661877b3a12482a3df2cad62ea2640c70a2cd1b7e077e76bc34eda68524b
-  data.tar.gz: a396ac9835b5f7432c83c8e38f545b01ff6b51ec8114b979c1af02c4493a64edff01d6488588570b77246cb2afb857caf859c82a0936eb744795ee8325c6820c
+  metadata.gz: 7f9d82a99a608ea35f4e78791dd1356536e9ca05f63c7698a79e509794a8b1eb313cbb93f4a96691bee4478d6d6e846a541bf5379ff0a65dbb73df8c0733f223
+  data.tar.gz: 77e2b25f473550b9d4ea775191ccc7ecaf7fe3cb2da7e16ae7c774d67de1181c85b98786ebe87375fd361e891dec7f06931026636375a8288b402381f1ecbb9d

data/lib/mini_apivore/declarative.rb

@@ -1,26 +1,31 @@
+# frozen_string_literal: true
+
 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}"
+unless defined?(ActiveSupport)
+  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
-end unless defined?(ActiveSupport)
+end

data/lib/mini_apivore/fragment.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 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)
+    def split(_options = nil)
       self
     end
   end

data/lib/mini_apivore/http_codes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "mini_apivore/version"
 
 module MiniApivore
@@ -7,4 +9,4 @@ module MiniApivore
   UNPROCESSABLE_ENTITY = 422
   OK = 200
   NO_CONTENT = 204
-end
+end

data/lib/mini_apivore/swagger.rb

@@ -1,42 +1,47 @@
-require "mini_apivore/version"
-require 'hashie'
+# frozen_string_literal: true
 
+require "mini_apivore/version"
+require "hashie"
 
 module MiniApivore
-  class Swagger < Hashie::Mash
-    NONVERB_PATH_ITEMS = %q(parameters)
+  class Swagger < Hash
+    include Hashie::Extensions::MergeInitializer
+
+    NONVERB_PATH_ITEMS = "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}"
+      when "2.0"
+        schema = File.read(File.expand_path("../../data/swagger_2.0_schema.json", __dir__))
+      else
+        raise "Unknown/unsupported Swagger version to validate against: #{version}"
       end
       JSON::Validator.fully_validate(schema, self)
     end
 
     def version
-      swagger
+      self['swagger']
     end
 
     def base_path
-      self['basePath'] || ''
+      self["basePath"] || ""
     end
 
     def each_response(&block)
-      paths.each do |path, path_data|
+      self['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?
+          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|
+          method_data['responses'].each do |response_code, response_data|
             schema_location = nil
-            if response_data.schema
+            if response_data['$ref']
+              schema_location = response_data['$ref']
+            elsif response_data['schema']
               schema_location = Fragment.new ['#', 'paths', path, verb, 'responses', response_code, 'schema']
             end
             block.call(path, verb, response_code, schema_location)
@@ -45,7 +50,7 @@ module MiniApivore
       end
     end
 
-    def vendor_specific_tag? tag
+    def vendor_specific_tag?(tag)
       tag =~ /\Ax-.*/
     end
   end

data/lib/mini_apivore/swagger_checker.rb

@@ -1,23 +1,26 @@
+# frozen_string_literal: true
+
+require "English"
 require "mini_apivore/version"
 
 module MiniApivore
   class SwaggerChecker
     PATH_TO_CHECKER_MAP = {}
 
-    def self.instance_for(path, schema = '' )
+    def self.instance_for(path, schema = "")
       PATH_TO_CHECKER_MAP[path] ||= new(path, schema)
     end
 
     def has_path?(path)
-      mappings.has_key?(path)
+      mappings.key?(path)
     end
 
     def has_method_at_path?(path, verb)
-      mappings[path].has_key?(verb)
+      mappings[path].key?(verb)
     end
 
     def has_response_code_for_path?(path, verb, code)
-      mappings[path][verb].has_key?(code.to_s)
+      mappings[path][verb].key?(code.to_s)
     end
 
     def response_codes_for_path(path, verb)
@@ -32,18 +35,17 @@ module MiniApivore
 
     def fragment(path, verb, code)
       path_fragment = mappings[path][verb.to_s][code.to_s]
-      path_fragment.dup unless path_fragment.nil?
+      path_fragment&.dup
     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
+      if untested_mappings[path][verb].size.zero?
         untested_mappings[path].delete(verb)
-        if untested_mappings[path].size == 0
-          untested_mappings.delete(path)
-        end
+        untested_mappings.delete(path) if untested_mappings[path].size.zero?
       end
     end
 
@@ -51,20 +53,14 @@ module MiniApivore
       @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
+    attr_accessor :response, :untested_mappings
+    attr_reader :swagger, :swagger_path
 
     private
 
     attr_reader :mappings
 
-    def initialize(swagger_path, schema )
+    def initialize(swagger_path, schema)
       @swagger_path = swagger_path
       @schema = schema
       load_swagger_doc!
@@ -79,15 +75,15 @@ module MiniApivore
 
     def fetch_swagger!
       return @schema unless @schema.empty?
-      
-      if File.exist?( swagger_path )
-        JSON.parse( File.read(swagger_path) )
+
+      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} - #{$!}."
+        rescue StandardError
+          raise "Unable to perform GET request for swagger json: #{swagger_path} - #{$ERROR_INFO}."
         end
         JSON.parse(session.response.body)
       end
@@ -98,7 +94,7 @@ module MiniApivore
       unless errors.empty?
         msg = "The document fails to validate as Swagger #{swagger.version}:\n"
         msg += errors.join("\n")
-        fail msg
+        raise msg
       end
     end
 
@@ -108,6 +104,7 @@ module MiniApivore
         @mappings[path] ||= {}
         @mappings[path][verb] ||= {}
         raise "duplicate" unless @mappings[path][verb][response_code].nil?
+
         @mappings[path][verb][response_code] = fragment
       end
 

data/lib/mini_apivore/to_param.rb

@@ -1,84 +1,98 @@
+# frozen_string_literal: true
+
 require "cgi"
 
-class Object
-  # Alias of <tt>to_s</tt>.
-  def to_param
-    to_s
-  end
+unless Object.method_defined?(:to_param)
+  class Object
+    # Alias of <tt>to_s</tt>.
+    def to_param
+      to_s
+    end
 
-  # Converts an object into a string suitable for use as a URL query string,
-  # using the given <tt>key</tt> as the param name.
-  def to_query(key)
-    "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
+    # Converts an object into a string suitable for use as a URL query string,
+    # using the given <tt>key</tt> as the param name.
+    def to_query(key)
+      "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
+    end
   end
-end unless Object.method_defined?( :to_param )
+end
 
-class NilClass
-  # Returns +self+.
-  def to_param
-    self
+unless NilClass.method_defined?(:to_param)
+  class NilClass
+    # Returns +self+.
+    def to_param
+      self
+    end
   end
-end unless NilClass.method_defined?( :to_param )
+end
 
-class TrueClass
-  # Returns +self+.
-  def to_param
-    self
+unless TrueClass.method_defined?(:to_param)
+  class TrueClass
+    # Returns +self+.
+    def to_param
+      self
+    end
   end
-end unless TrueClass.method_defined?( :to_param )
+end
 
-class FalseClass
-  # Returns +self+.
-  def to_param
-    self
+unless FalseClass.method_defined?(:to_param)
+  class FalseClass
+    # Returns +self+.
+    def to_param
+      self
+    end
   end
-end unless FalseClass.method_defined?( :to_param )
+end
 
-class Array
-  # Calls <tt>to_param</tt> on all its elements and joins the result with
-  # slashes. This is used by <tt>url_for</tt> in Action Pack.
-  def to_param
-    collect(&:to_param).join "/"
-  end
+unless Array.method_defined?(:to_param)
+  class Array
+    # Calls <tt>to_param</tt> on all its elements and joins the result with
+    # slashes. This is used by <tt>url_for</tt> in Action Pack.
+    def to_param
+      collect(&:to_param).join("/")
+    end
 
-  # Converts an array into a string suitable for use as a URL query string,
-  # using the given +key+ as the param name.
-  #
-  #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
-  def to_query(key)
-    prefix = "#{key}[]"
+    # Converts an array into a string suitable for use as a URL query string,
+    # using the given +key+ as the param name.
+    #
+    #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
+    def to_query(key)
+      prefix = "#{key}[]"
 
-    if empty?
-      nil.to_query(prefix)
-    else
-      collect { |value| value.to_query(prefix) }.join "&"
+      if empty?
+        nil.to_query(prefix)
+      else
+        collect { |value| value.to_query(prefix) }.join("&")
+      end
     end
   end
-end unless Array.method_defined?( :to_param )
+end
 
-class Hash
-  # Returns a string representation of the receiver suitable for use as a URL
-  # query string:
-  #
-  #   {name: 'David', nationality: 'Danish'}.to_query
-  #   # => "name=David&nationality=Danish"
-  #
-  # An optional namespace can be passed to enclose key names:
-  #
-  #   {name: 'David', nationality: 'Danish'}.to_query('user')
-  #   # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
-  #
-  # The string pairs "key=value" that conform the query string
-  # are sorted lexicographically in ascending order.
-  #
-  # This method is also aliased as +to_param+.
-  def to_query(namespace = nil)
-    collect do |key, value|
-      unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
-        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
-      end
-    end.compact.sort! * "&"
-  end
+unless Hash.method_defined?(:to_param)
+  class Hash
+    # Returns a string representation of the receiver suitable for use as a URL
+    # query string:
+    #
+    #   {name: 'David', nationality: 'Danish'}.to_query
+    #   # => "name=David&nationality=Danish"
+    #
+    # An optional namespace can be passed to enclose key names:
+    #
+    #   {name: 'David', nationality: 'Danish'}.to_query('user')
+    #   # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
+    #
+    # The string pairs "key=value" that conform the query string
+    # are sorted lexicographically in ascending order.
+    #
+    # This method is also aliased as +to_param+.
+    def to_query(namespace = nil)
+      collect do |key, value|
+        unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
+          value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+        end
+      end.compact.sort! * "&"
+    end
 
-  alias_method :to_param, :to_query
-end unless Hash.method_defined?( :to_param )
+    alias_method :to_param, :to_query
+  end
+end

data/lib/mini_apivore/validation.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require "mini_apivore/version"
 
 module MiniApivore
-  module Validation # former Validator
-
+  # former Validator
+  module Validation
     class IndHash < Hash
       include Hashie::Extensions::MergeInitializer
       include Hashie::Extensions::IndifferentAccess
     end
 
-    def prepare_action_env(verb, path, expected_response_code, params = {})
+    def prepare_action_env(verb, path, expected_response_code, **params)
       @errors = []
       @verb = verb.to_s
       @path = path.to_s
@@ -16,46 +18,45 @@ module MiniApivore
       @expected_response_code = expected_response_code.to_i
     end
 
-    def swagger_checker; self.class.swagger_checker 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?, <<FAIL )
+    def check_route(verb, path, expected_response_code, **params)
+      prepare_action_env(verb, path, expected_response_code, **params)
+      assert(match?, <<FAIL)
     Failed at: #{prepare_error_backtrace}\n
-    Failure message: #{failure_message},\n 
-    fullpath: #{full_path}, \n 
+    Failure message: #{failure_message},\n#{" "}
+    fullpath: #{full_path}, \n#{" "}
     params causing failure:#{params}
 FAIL
     end
 
     def prepare_error_backtrace
       # it will deliver something like this:
-      #"/app/test/helpers/base_routes_helpers.rb:57:in `__create_card'",
-      #"/app/test/integration/cards_api_test.rb:71:in `block (2 levels) in <class:CommentsApiTest>'",
-      Thread.current.backtrace[2..-1].slice_after{|trc| trc[/check_route/] }.to_a.last[0..1]
+      # "/app/test/helpers/base_routes_helpers.rb:57:in `__create_card'",
+      # "/app/test/integration/cards_api_test.rb:71:in `block (2 levels) in <class:CommentsApiTest>'",
+      Thread.current.backtrace[2..].slice_after { |trc| trc[/check_route/] }.to_a.last[0..1]
     end
 
     def match?
-      #pre_checks
+      # pre_checks
       check_request_path
 
       # request
       unless has_errors?
-        send(
+        action_dispatch_request(
           @verb,
-          *action_dispatch_request_args(
-            full_path,
-            params: @params['_data'] || {},
-            headers: @params['_headers'] || {}
-          )
+          full_path,
+          params: @params["_data"] || {},
+          headers: @params["_headers"] || {}
         )
 
-        #post_checks
+        # post_checks
         check_status_code
         check_response_is_valid unless has_errors?
 
-
-        if has_errors? && response.body.length > 0
+        if has_errors? && response.body.length.positive?
           @errors << "\nResponse body:\n #{JSON.pretty_generate(JSON.parse(response.body))}"
         end
 
@@ -69,19 +70,19 @@ FAIL
     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}"
+          " 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}"
+          " 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)}"
+          " 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}"
+          " response model for get request with #{@path} for code"\
+          " #{@expected_response_code}"
       end
     end
 
@@ -90,56 +91,59 @@ FAIL
     end
 
     def apivore_build_path(path, data)
-      path.scan(/\{([^\}]*)\}/).each do |param|
+      path.scan(/\{([^}]*)\}/).each do |param|
         key = param.first
-        dkey = data && ( data[key] || data[key.to_sym] )
+        dkey = data && (data[key] || data[key.to_sym])
         if dkey
-          path = path.gsub "{#{key}}", dkey.to_param.to_s
+          path = path.gsub("{#{key}}", dkey.to_param.to_s)
         else
           raise URI::InvalidURIError, "No substitution data found for {#{key}}"\
-              " to test the path #{path}.", caller
+            " to test the path #{path}.", caller
         end
       end
-      path + (data['_query_string'] ? "?#{data['_query_string'].to_param}" : '')
+      path + (data["_query_string"] ? "?#{data["_query_string"].to_param}" : "")
     end
 
-    def has_errors?; !@errors.empty?  end
+    def has_errors?
+      !@errors.empty?
+    end
 
-    def failure_message; @errors.join(" ") 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
+          " 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
+      return if swagger_errors.empty?
+
+      @errors.concat(
+        swagger_errors.map do |e|
+          e.sub("'#", "'#{full_path}#").gsub(
+            /^The property|in schema.*$/, ""
+          )
+        end
+      )
     end
 
     def response_body
       JSON.parse(response.body) if response.body && !response.body.empty?
     end
 
-    def action_dispatch_request_args(path, params: {}, headers: {})
+    def action_dispatch_request(verb, path, params: {}, headers: {})
       if defined?(ActionPack) && ActionPack::VERSION::MAJOR >= 5
-        [path, params: params, headers: headers]
+        send(verb, path, params: params, headers: headers)
       else
-        [path, params, headers]
+        send(verb, path, params, headers)
       end
     end
   end
-
-end
+end

data/lib/mini_apivore/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Mini
   module Apivore
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/lib/mini_apivore.rb

@@ -1,17 +1,24 @@
-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'
-require 'mini_apivore/to_param'
+# frozen_string_literal: true
+
+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"
+require "mini_apivore/to_param"
 
 module MiniApivore
   SWAGGER_CHECKERS = {}
   #----- Module globals -----------------
-  def self.runnable_list; @@runnable_list ||= []  end
-  def self.all_test_ran?; runnable_list.empty? end
+  def self.runnable_list
+    @@runnable_list ||= [] # rubocop:disable Style/ClassVars
+  end
+
+  def self.all_test_ran?
+    runnable_list.empty?
+  end
 
   def self.prepare_untested_errors
     errors = []
@@ -19,7 +26,7 @@ module MiniApivore
       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}"
+            errors << "#{method} #{path} is untested for response code #{code} in test class #{cls}"
           end
         end
       end
@@ -28,26 +35,25 @@ module MiniApivore
   end
 
   def self.included(base)
-    base.extend ClassMethods
-    base.include MiniApivore::Validation
+    base.extend(ClassMethods)
+    base.include(MiniApivore::Validation)
   end
 
   #---- class methods -----------
   module ClassMethods
-
-    def init_swagger( swagger_path, schema= '' )
+    def init_swagger(swagger_path, schema = "")
       SWAGGER_CHECKERS[self] ||= MiniApivore::SwaggerChecker.instance_for(swagger_path, schema)
     end
 
     def runnable_methods
-      super | ['final_test']
+      super | ["final_test"]
     end
 
-    def test(name, &block )
-      super( name, &block ).tap{ |sym| MiniApivore.runnable_list << "#{to_s}::#{sym}" }
+    def test(name, &block)
+      super(name, &block).tap { |sym| MiniApivore.runnable_list << "#{self}::#{sym}" }
     end
 
-    def swagger_checker;
+    def swagger_checker
       SWAGGER_CHECKERS[self]
     end
   end
@@ -55,7 +61,7 @@ module MiniApivore
   #----- Minitest callback -----------
   def teardown
     super
-    MiniApivore.runnable_list.delete( "#{self.class.to_s}::#{@NAME}" )
+    MiniApivore.runnable_list.delete("#{self.class}::#{@NAME}")
   end
 
   #----- test for untested routes ---------
@@ -63,13 +69,9 @@ module MiniApivore
     return unless MiniApivore.all_test_ran?
 
     @errors = MiniApivore.prepare_untested_errors
-    assert( @errors.empty?, @errors.join("\n") )
+    assert(@errors.empty?, @errors.join("\n"))
 
     # preventing duplicate execution
-    MiniApivore.runnable_list << "#{self.class.to_s}::#{__method__}_runned"
+    MiniApivore.runnable_list << "#{self.class}::#{__method__}_runned"
   end
-
-
 end
-
-

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: mini-apivore
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - alekseyl
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-23 00:00:00.000000000 Z
+date: 2022-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: json-schema
+  name: hashie
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: json-schema
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '2.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '2.5'
 - !ruby/object:Gem::Dependency
-  name: hashie
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 12.3.3
+- !ruby/object:Gem::Dependency
+  name: rubocop-shopify
+  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'
 description: " Minitest adaptation of apivore gem,\n                           Provides
   a tool for testing your application api against your swagger schema "
 email: