fitting 3.0.2 → 4.0.0

data/lib/fitting/records/tested/request.rb

@@ -11,6 +11,10 @@ module Fitting
           @response = response
         end
 
+        def host
+          @host ||= @response.request.host
+        end
+
         def method
           @method ||= @response.request.request_method
         end
@@ -42,7 +46,8 @@ module Fitting
             body: body,
             response: fitting_response.to_spherical,
             title: test_path,
-            group: test_file_path
+            group: test_file_path,
+            host: host
           )
         end
       end

data/lib/fitting/records/tested/response.rb

@@ -16,10 +16,15 @@ module Fitting
           @body ||= @response.body
         end
 
+        def content_type
+          @content_type ||= @response.content_type
+        end
+
         def to_spherical
           Fitting::Records::Spherical::Response.new(
             status: status,
-            body: body
+            body: body,
+            content_type: content_type
           )
         end
       end

data/lib/fitting/rep/html.rb

@@ -0,0 +1,32 @@
+module Fitting
+  class Rep
+    class HTML
+      def self.copy_file(folder, name)
+        File.open("#{folder}/#{name}", 'w') do |file|
+          file.write(
+            File.read("#{$LOAD_PATH.find { |i| i.include?('fitting') }}/templates/htmlcss/#{name}")
+          )
+        end
+      end
+
+      def self.copy_file_with_json(folder, name, fitting_json, fitting_lock_json)
+        res = File.read("#{$LOAD_PATH.find { |i| i.include?('fitting') }}/templates/htmlcss/#{name}")
+        File.open("#{folder}/#{name}", 'w') do |file|
+          file.write(
+            res
+              .gsub("{'fitting json': []}", ::JSON.pretty_generate(fitting_json))
+              .gsub("{'fitting lock json': []}", ::JSON.pretty_generate(fitting_lock_json))
+          )
+        end
+      end
+
+      def self.bootstrap(folder, fitting_json, fitting_lock_json)
+        copy_file_with_json(folder, 'fitting.html', fitting_json, fitting_lock_json)
+        copy_file(folder, 'bootstrap-nightshade.min.css')
+        copy_file(folder, 'darkmode.min.js')
+        copy_file(folder, 'jquery-3.6.0.min.js')
+        copy_file(folder, 'bootstrap.min.js')
+      end
+    end
+  end
+end

data/lib/fitting/rep.rb

@@ -0,0 +1,24 @@
+require 'fitting/rep/html'
+
+module Fitting
+  class Rep
+    def initialize(apis)
+      @actions = apis
+    end
+
+    def save!
+      destination = 'coverage'
+      FileUtils.mkdir_p(destination)
+
+      fitting_json = @actions.inject({}) do |sum, action|
+        sum.merge(action.to_hash)
+      end
+      fitting_lock_json = @actions.inject({}) do |sum, action|
+        sum.merge(action.to_hash_lock)
+      end
+      File.open('coverage/.fitting.json', 'w') { |file| file.write(::JSON.pretty_generate(fitting_json)) }
+      File.open('coverage/.fitting.lock.json', 'w') { |file| file.write(::JSON.pretty_generate(fitting_lock_json)) }
+      Fitting::Rep::HTML.bootstrap('coverage', fitting_json, fitting_lock_json)
+    end
+  end
+end

data/lib/fitting/report/action.rb

@@ -5,8 +5,16 @@ module Fitting
     class Action
       def initialize(action)
         @action = action
-        @tests = Fitting::Report::Tests.new([])
         @responses = Fitting::Report::Responses.new(@action.responses)
+        @cover = false
+      end
+
+      def cover?
+        @cover
+      end
+
+      def cover!
+        @cover = true
       end
 
       def method
@@ -19,10 +27,6 @@ module Fitting
 
       attr_reader :responses, :tests
 
-      def add_test(test)
-        @tests.push(test)
-      end
-
       def path_match(find_path)
         regexp =~ find_path
       end
@@ -35,16 +39,6 @@ module Fitting
         str = "\\A#{str}\\z"
         @regexp = Regexp.new(str)
       end
-
-      def details
-        {
-          tests_without_responses: @tests.without_responses,
-          responses_details: @responses.to_a.map do |r|
-                               { method: r.status, tests_size: r.tests.size, json_schema: r.id,
-                                 combinations: r.details }
-                             end
-        }
-      end
     end
   end
 end

data/lib/fitting/report/actions.rb

@@ -3,54 +3,43 @@ require 'fitting/report/action'
 module Fitting
   module Report
     class Actions
-      def initialize(actions)
-        @actions = []
-        actions.to_a.map do |action|
-          @actions.push(Fitting::Report::Action.new(action))
+      class Empty < RuntimeError; end
+      class NotFound < RuntimeError
+        attr_reader :log
+
+        def initialize(msg, log)
+          @log = log
+          super(msg)
         end
       end
 
-      def to_a
-        @actions
-      end
+      def cover!
 
-      def push(actions)
-        @actions += actions.to_a
       end
 
-      def join(tests)
-        tests.to_a.map do |test|
-          if there_a_suitable_action?(test)
-            cram_into_the_appropriate_action(test)
-            test.mark_action
-          end
+      def initialize(actions)
+        @actions = []
+        actions.to_a.map do |action|
+          @actions.push(Fitting::Report::Action.new(action))
         end
       end
 
-      def there_a_suitable_action?(test)
+      def find!(log)
+        raise Empty if @actions.empty?
         @actions.map do |action|
-          return true if test.method == action.method && action.path_match(test.path)
+          if log.method == action.method && action.path_match(log.path)
+            return action
+          end
         end
-
-        false
+        raise NotFound.new("method: #{log.method}, host: #{log.host}, path: #{log.path}", log)
       end
 
-      def cram_into_the_appropriate_action(test)
-        @actions.map do |action|
-          if test.method == action.method && action.path_match(test.path)
-            action.add_test(test)
-            break
-          end
-        end
+      def to_a
+        @actions
       end
 
-      def details(prefix)
-        {
-          tests_without_actions: prefix.tests.without_actions,
-          actions_details: @actions.map do |a|
-                             { method: a.method, path: a.path, tests_size: a.tests.size, responses: a.details }
-                           end
-        }
+      def push(actions)
+        @actions += actions.to_a
       end
     end
   end

data/lib/fitting/report/combination.rb

@@ -5,18 +5,22 @@ module Fitting
         @json_schema = json_schema
         @type = type
         @combination = combination
-        @tests = Fitting::Report::Tests.new([])
         @id = SecureRandom.hex
+        @cover = false
       end
 
-      attr_reader :json_schema, :id, :type, :tests
+      attr_reader :json_schema, :id, :type
 
-      def name
-        @combination
+      def cover?
+        @cover
+      end
+
+      def cover!
+        @cover = true
       end
 
-      def add_test(test)
-        @tests.push(test)
+      def name
+        @combination
       end
     end
   end

data/lib/fitting/report/combinations.rb

@@ -1,6 +1,9 @@
 module Fitting
   module Report
     class Combinations
+      class Empty < RuntimeError; end
+      class NotFound < RuntimeError; end
+
       def initialize(combinations)
         @combinations = combinations
       end
@@ -9,37 +12,14 @@ module Fitting
         @combinations
       end
 
-      def size
-        @combinations.size
-      end
-
-      def size_with_tests
-        @combinations.count { |c| c.tests.size != 0 }
-      end
-
-      def join(tests)
-        tests.to_a.map do |test|
-          if there_a_suitable_combination?(test)
-            cram_into_the_appropriate_combinations(test)
-            test.mark_combination
-          end
-        end
-      end
-
-      def there_a_suitable_combination?(test)
-        return false if @combinations.nil?
-
-        @combinations.map do |combination|
-          return true if JSON::Validator.fully_validate(combination.json_schema, test.body) == []
-        end
-
-        false
-      end
-
-      def cram_into_the_appropriate_combinations(test)
+      def find!(test)
+        raise Empty if @combinations.empty?
         @combinations.map do |combination|
-          combination.add_test(test) if JSON::Validator.fully_validate(combination.json_schema, test.body) == []
+          if JSON::Validator.fully_validate(combination.json_schema, test.body) == []
+            return combination
+          end
         end
+        raise NotFound
       end
     end
   end

data/lib/fitting/report/prefix.rb

@@ -11,15 +11,14 @@ module Fitting
         'tomogram' => :tomogram_json_path
       }.freeze
 
-      attr_reader :name, :tests, :actions
+      attr_reader :name, :actions
 
       def initialize(schema_paths: nil, type: nil, name: '', skip: false, only: [])
         @name = name
-        @tests = Fitting::Report::Tests.new([])
-        @skip = skip
-        return if skip
+        @cover = false
 
         @actions = Fitting::Report::Actions.new([])
+        return if skip
 
         schema_paths.each do |path|
           tomogram = Tomograph::Tomogram.new(prefix: name, KEYS[type] => path)
@@ -30,28 +29,12 @@ module Fitting
         end
       end
 
-      def skip?
-        @skip
-      end
-
-      def details
-        if @skip
-          {
-            name: @name,
-            tests_size: @tests.size,
-            actions: { tests_without_actions: [], actions_details: [] }
-          }
-        else
-          {
-            name: @name,
-            tests_size: @tests.size,
-            actions: @actions.details(self)
-          }
-        end
+      def cover!
+        @cover = true
       end
 
-      def add_test(test)
-        @tests.push(test)
+      def cover?
+        @cover
       end
     end
   end

data/lib/fitting/report/prefixes.rb

@@ -19,37 +19,23 @@ module Fitting
         end
       end
 
-      def there_a_suitable_prefix?(test_path)
-        @prefixes.map do |prefix|
-          return true if prefix.name.nil?
-          return true if prefix.name == ''
-          return true if test_path[0..prefix.name.size - 1] == prefix.name
-        end
-
-        false
+      def to_a
+        @prefixes
       end
 
-      def cram_into_the_appropriate_prefix(test)
+      def find!(test)
         @prefixes.map do |prefix|
-          if prefix.name.nil? || prefix.name == '' || test.path[0..prefix.name.size - 1] == prefix.name
-            prefix.add_test(test)
-            break
+          puts test.path
+          puts test.host
+          puts test.method
+          puts test.status
+          puts test.body
+          puts prefix.name
+          if test.path[0..prefix.name.size - 1] == prefix.name
+            return prefix
           end
         end
       end
-
-      def join(tests)
-        tests.to_a.map do |test|
-          if there_a_suitable_prefix?(test.path)
-            cram_into_the_appropriate_prefix(test)
-            test.mark_prefix
-          end
-        end
-      end
-
-      def to_a
-        @prefixes
-      end
     end
   end
 end

data/lib/fitting/report/response.rb

@@ -1,13 +1,24 @@
 require 'fitting/report/combinations'
 require 'fitting/report/combination'
+require 'fitting/cover/json_schema'
+require 'fitting/cover/json_schema_enum'
+require 'fitting/cover/json_schema_one_of'
 
 module Fitting
   module Report
     class Response
       def initialize(response)
         @response = response
-        @tests = Fitting::Report::Tests.new([])
         @id = SecureRandom.hex
+        @cover = false
+      end
+
+      def cover?
+        @cover
+      end
+
+      def cover!
+        @cover = true
       end
 
       def status
@@ -20,10 +31,6 @@ module Fitting
 
       attr_reader :id, :tests
 
-      def add_test(test)
-        @tests.push(test)
-      end
-
       def combinations
         return @combinations if @combinations
 
@@ -45,23 +52,6 @@ module Fitting
 
         @combinations = Fitting::Report::Combinations.new(cmbntns)
       end
-
-      def cover_percent
-        return '0%' if @tests.size.zero?
-        return '100%' if @combinations.size.zero?
-
-        "#{(@combinations.size_with_tests + 1) * 100 / (@combinations.size + 1)}%"
-      end
-
-      def details
-        {
-          cover_percent: cover_percent,
-          tests_without_combinations: @tests.without_combinations,
-          combinations_details: @combinations.to_a.map do |c|
-                                  { json_schema: c.id, tests_size: c.tests.size, type: c.type, name: c.name }
-                                end
-        }
-      end
     end
   end
 end

data/lib/fitting/report/responses.rb

@@ -3,6 +3,15 @@ require 'fitting/report/response'
 module Fitting
   module Report
     class Responses
+      class NotFound < RuntimeError
+        attr_reader :log
+
+        def initialize(msg, log)
+          @log = log
+          super(msg)
+        end
+      end
+
       def initialize(responses)
         @responses = responses
         @responses = []
@@ -11,38 +20,25 @@ module Fitting
         end
       end
 
-      def to_a
-        @responses
-      end
-
-      def join(tests)
-        tests.to_a.map do |test|
-          if there_a_suitable_response?(test)
-            cram_into_the_appropriate_response(test)
-            test.mark_response
-          end
-        end
-      end
-
-      def there_a_suitable_response?(test)
-        return false if @responses.nil?
-
+      def find!(log)
+        message = ""
         @responses.map do |response|
-          return true if response.status.to_s == test.status &&
-                         JSON::Validator.fully_validate(response.body, test.body) == []
+          if response.status.to_s == log.status
+            if JSON::Validator.fully_validate(response.body, log.body) == []
+              return response
+            else
+              message += "\nbody: #{response.body}\nvalidate: #{JSON::Validator.fully_validate(response.body, log.body)}\n"
+            end
+          else
+            message += "\nstatus: #{response.status}\n"
+          end
         end
 
-        false
+        raise NotFound.new("method: #{log.method}, host: #{log.host}, path: #{log.path}, status: #{log.status}, body: #{log.body}\n\n#{message}", log)
       end
 
-      def cram_into_the_appropriate_response(test)
-        @responses.map do |response|
-          next unless response.status.to_s == test.status &&
-                      JSON::Validator.fully_validate(response.body, test.body) == []
-
-          response.add_test(test)
-          break
-        end
+      def to_a
+        @responses
       end
     end
   end

data/lib/fitting/report/tests.rb

@@ -11,10 +11,8 @@ module Fitting
 
       def self.new_from_config
         tests = []
-        Dir["#{Fitting.configuration.rspec_json_path}/*.json"].each do |file|
-          JSON.parse(File.read(file)).map do |test|
-            tests.push(Fitting::Report::Test.new(test))
-          end
+        File.read('log/test.log').split("\n").select{|f|f.include?('incoming request ')}.each do |test|
+          tests.push(Fitting::Report::Test.new(JSON.load(test.split('incoming request ')[1])))
         end
         tests.sort { |a, b| b.path <=> a.path }
         new(tests)
@@ -22,10 +20,8 @@ module Fitting
 
       def self.new_from_outgoing_config
         tests = []
-        Dir["#{Fitting.configuration.webmock_json_path}/*.json"].each do |file|
-          JSON.parse(File.read(file)).map do |test|
-            tests.push(Fitting::Report::Test.new(test))
-          end
+        File.read('log/test.log').split("\n").select{|f|f.include?('outgoing request ')}.each do |test|
+          tests.push(Fitting::Report::Test.new(JSON.load(test.split('outgoing request ')[1])))
         end
         tests.sort { |a, b| b.path <=> a.path }
         new(tests)

data/lib/fitting/skip/action.rb

@@ -0,0 +1,44 @@
+module Fitting
+  class Skip
+    class Action
+      attr_accessor :host, :method, :path, :code
+
+      def initialize(host, method, path, code)
+        @host = host
+        @method = method
+        @path = path
+        @code = code
+      end
+
+      def self.all(actions)
+        return [] unless actions
+        actions.map do |action|
+          next if action['method'].nil? || action['path'].nil?
+          new(action['host'], action['method'], action['path'], action['code'])
+        end.compact
+      end
+
+      def self.find(actions, log)
+        actions.find do |action|
+          if action.host == log.host &&
+            action.method == log.method &&
+            action.path_match(log.path)
+            return action if action.code == nil
+            return action if action.code.to_s == log.status
+          end
+        end
+      end
+
+      def path_match(find_path)
+        regexp =~ find_path
+      end
+
+      def regexp
+        str = Regexp.escape(path)
+        str = str.gsub(/\\{\w+\\}/, '[^&=\/]+')
+        str = "\\A#{str}\\z"
+        Regexp.new(str)
+      end
+    end
+  end
+end

data/lib/fitting/skip/api.rb

@@ -0,0 +1,29 @@
+module Fitting
+  class Skip
+    class API
+      attr_accessor :type, :host, :prefix, :path
+
+      def initialize(type, host, prefix)
+        @type = type
+        @host = host
+        @prefix = prefix
+      end
+
+      def self.all(apis)
+        return [] unless apis
+        apis.map do |api|
+          next if api['method'] || api['path']
+          new('provided', api['host'], api['prefix'])
+        end.compact
+      end
+
+      def self.find(apis, log)
+        apis.find do |api|
+          if log.host == api.host
+            api.prefix.nil? || api.prefix == '' || log.path[0..api.prefix.size - 1] == api.prefix
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fitting/skip.rb

@@ -0,0 +1,21 @@
+require 'fitting/skip/api'
+require 'fitting/skip/action'
+
+module Fitting
+  class Skip
+    def self.all
+      yaml = YAML.safe_load(File.read('.fitting.yml'))
+      {
+        apis: Fitting::Skip::API.all(yaml['SkipValidation']),
+        actions: Fitting::Skip::Action.all(yaml['SkipValidation'])
+      }
+    end
+
+    def self.find(skips, log)
+      api = Fitting::Skip::API.find(skips[:apis], log)
+      return api if api
+
+      Fitting::Skip::Action.find(skips[:actions], log)
+    end
+  end
+end

data/lib/fitting/version.rb

@@ -1,3 +1,3 @@
 module Fitting
-  VERSION = '3.0.2'.freeze
+  VERSION = '4.0.0'.freeze
 end