fitting 3.0.2 → 4.0.1

data/lib/fitting/prefix.rb

@@ -0,0 +1,62 @@
+require 'fitting/report/actions'
+
+module Fitting
+  class Prefix
+    KEYS = {
+      'openapi2' => :openapi2_json_path,
+      'openapi3' => :openapi3_yaml_path,
+      'drafter' => :drafter_yaml_path,
+      'crafter' => :crafter_yaml_path,
+      'tomogram' => :tomogram_json_path
+    }.freeze
+
+    attr_reader :name, :actions
+
+    def initialize(name, schema_paths, type, skip = false)
+      @prefix = name
+      @cover = false
+
+      @actions = Fitting::Report::Actions.new([])
+      raise Skip if skip
+
+      schema_paths.each do |path|
+        tomogram = Tomograph::Tomogram.new(prefix: name, KEYS[type] => path)
+
+        @actions.push(Fitting::Report::Actions.new(tomogram))
+      end
+    end
+
+    class Skip < RuntimeError; end
+
+    class NotFound < RuntimeError
+      attr_reader :log
+
+      def initialize(msg, log)
+        @log = log
+        super(msg)
+      end
+    end
+
+    def self.find(host:, log:)
+      yaml = YAML.safe_load(File.read('.fitting.yml'))
+
+      prefixes = yaml['hosts'].find{|h| h.first.first == host.to_s}.first.last['prefixes']
+      raise NotFound.new("host: #{log.host}, path: #{log.path}", log) unless prefixes
+
+      prefix = prefixes.find do |prefix|
+        prefix['name'].nil? || log.path[0..prefix['name'].size - 1] == prefix['name']
+      end
+      raise NotFound.new("host: #{log.host}, path: #{log.path}", log) unless prefix
+
+      new(prefix['name'], prefix['schema_paths'], prefix['type'], prefix['skip'])
+    end
+
+    def cover!
+      @cover = true
+    end
+
+    def cover?
+      @cover
+    end
+  end
+end

data/lib/fitting/railtie.rb

@@ -4,7 +4,6 @@ module Fitting
   class MyRailtie < Rails::Railtie
     rake_tasks do
       load 'tasks/fitting.rake'
-      load 'tasks/fitting_outgoing.rake'
     end
   end
 end

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

@@ -5,15 +5,16 @@ module Fitting
   class Records
     class Spherical
       class Request
-        attr_reader :method, :path, :body, :response, :title, :group
+        attr_reader :method, :path, :body, :response, :title, :group, :host
 
-        def initialize(method:, path:, body:, response:, title:, group:)
+        def initialize(method:, path:, body:, response:, title:, group:, host:)
           @method = method
           @path = path
           @body = body
           @response = response
           @title = title
           @group = group
+          @host = host
         end
 
         def to_hash
@@ -23,7 +24,8 @@ module Fitting
             body: body,
             response: response.to_hash,
             title: title,
-            group: group
+            group: group,
+            host: host
           }
         end
 
@@ -39,7 +41,8 @@ module Fitting
               body: hash['body'],
               response: Fitting::Records::Spherical::Response.load(hash['response']),
               title: hash['title'],
-              group: hash['group']
+              group: hash['group'],
+              host: hash['host']
             )
           end
         end

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

@@ -6,32 +6,38 @@ module Fitting
       class Response
         attr_reader :status, :body
 
-        def initialize(status:, body:)
+        def initialize(status:, body:, content_type:)
           @status = status
           @body = body
+          @content_type = content_type
         end
 
         def to_hash
-          {
-            status: status,
-            body: JSON.parse(body)
-          }
-        rescue JSON::ParserError
-          {
-            status: status,
-            body: {}
-          }
+          begin
+            parse_body =  JSON.parse(body)
+          rescue JSON::ParserError
+            parse_body = {}
+          end
+
+          if @content_type == nil || @content_type == ''
+            {
+              status: status,
+              content_type: 'application/json',
+              body: parse_body
+            }
+          else
+            ct = @content_type.split("; ")
+            {
+              status: status,
+              content_type: ct.first,
+              body: parse_body
+            }
+          end
         end
 
         def to_json(*_args)
           JSON.dump(to_hash)
         end
-
-        class << self
-          def load(hash)
-            new(status: hash['status'], body: hash['body'])
-          end
-        end
       end
     end
   end

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