fitting 3.0.2 → 4.0.1

data/lib/fitting/action.rb

@@ -0,0 +1,105 @@
+require 'fitting/host'
+require 'fitting/prefix'
+require 'fitting/report/prefixes'
+
+module Fitting
+  class Action
+    class Skip < RuntimeError; end
+    class Empty < RuntimeError; end
+    class NotFound < RuntimeError
+      attr_reader :log
+
+      def initialize(msg, log)
+        @log = log
+        super(msg)
+      end
+    end
+
+    def initialize(action)
+      @action = action
+    end
+
+    def action
+      @action
+    end
+
+    def self.all
+      []
+    end
+
+    def self.find!(actions, log)
+      host = Fitting::Host.find!(log)
+      host.cover!
+
+      prefix = Fitting::Prefix.find(host: host, log: log)
+      prefix.cover!
+
+      new(prefix.actions.find!(log))
+    rescue Fitting::Report::Actions::Empty,
+      Fitting::Host::Skip,
+      Fitting::Prefix::Skip
+      raise Skip
+    rescue Fitting::Report::Combinations::Empty,
+      Fitting::Report::Combinations::NotFound
+      raise Skip
+    rescue Fitting::Host::NotFound,
+      Fitting::Prefix::NotFound,
+      Fitting::Report::Actions::NotFound,
+      Fitting::Report::Responses::NotFound => e
+      raise NotFound.new(e.message, log)
+    end
+
+    def cover!(log)
+      action.cover!
+
+      response = action.responses.find!(log)
+      response.cover!
+
+      combination = response.combinations.find!(log)
+      combination.cover!
+
+      print "\e[32m.\e[0m"
+    rescue Fitting::Report::Actions::Empty,
+      Fitting::Host::Skip,
+      Fitting::Prefix::Skip
+    rescue Fitting::Report::Combinations::Empty,
+      Fitting::Report::Combinations::NotFound
+    rescue Fitting::Host::NotFound,
+      Fitting::Prefix::NotFound,
+      Fitting::Report::Actions::NotFound,
+      Fitting::Report::Responses::NotFound => e
+    end
+
+    def self.report(actions)
+      all = 0
+      cover = 0
+
+      # prefixes.to_a.map do |prefix|
+      #   all += 1
+      #   break unless prefix.cover?
+      #   cover += 1
+      #   prefix.actions.to_a.map do |action|
+      #     all += 1
+      #     break unless action.cover?
+      #     cover += 1
+      #     action.responses.to_a.map do |response|
+      #       all += 1
+      #       break unless action.cover?
+      #       cover += 1
+      #       response.combinations.to_a.map do |combination|
+      #         all += 1
+      #         break unless combination.cover?
+      #         cover += 1
+      #       end
+      #     end
+      #   end
+      # end
+
+      puts
+      puts "Coverage #{(cover.to_f / all.to_f * 100).round(2)}%"
+      exit 1 unless false
+
+      exit 0
+    end
+  end
+end

data/lib/fitting/cover/json_schema.rb

@@ -17,12 +17,12 @@ module Fitting
 
       def inception(json_schema, combinations)
         json_schema.each do |key, value|
-          if (key == 'properties') && (json_schema['required'] != value.keys)
+          if (key == 'properties') && value && (json_schema['required'] != value.keys)
             schema = json_schema.dup
             one_of = schema.delete('required') || []
             schema['properties'].each_key do |property|
               next if one_of.include?(property)
-
+              next if property == 'type' || property == 'properties'
               combinations.push([schema.merge('required' => one_of + [property]), "required.#{property}"])
             end
           elsif value.is_a?(Hash)

data/lib/fitting/cover/json_schema_one_of.rb

@@ -10,7 +10,7 @@ module Fitting
 
       def combi
         inception(json_schema, combinations).each do |combination|
-          combination[0] = json_schema.merge(combination[0])
+          combination[0] = combination[0]
           combination[1] = ['one_of', combination[1]]
         end
       end
@@ -21,7 +21,9 @@ module Fitting
             schema = json_schema.dup
             one_of = schema.delete('oneOf')
             one_of.each_index do |index|
-              combinations.push([schema.merge('oneOf' => [one_of[index]]), "oneOf.#{index}"])
+              schema_new = json_schema.dup
+              schema_new.delete('oneOf')
+              combinations.push([schema_new.merge(one_of[index]), "oneOf.#{index}"])
             end
           elsif value.is_a?(Hash)
             com = inception(value, [])

data/lib/fitting/debug.rb

@@ -0,0 +1,47 @@
+module Fitting
+  class Debug
+    attr_accessor :host, :method, :path, :status, :content_type
+
+    def initialize(host, method, path, code, content_type)
+      @host = host
+      @method = method
+      @path = path
+      @status = code.to_s
+      @content_type = content_type
+    end
+
+    def self.save!(docs, yaml)
+      return unless yaml['Debug']
+      yaml['Debug'].map do |action|
+        debug = new(action['host'], action['method'], action['path'], action['code'], action['content-type'])
+        res = Fitting::Doc.debug(docs, debug)
+        index = res.next_steps.first.index_before
+        next_steps_first = res.next_steps.first
+        res_debug = report(index, next_steps_first, res.logs)
+        File.open('coverage/.fitting.debug.yml', 'w') { |file| file.write(YAML.dump(res_debug)) }
+      end
+    end
+
+    def self.report(index, next_steps_first, res_logs)
+      return {} if index.nil?
+      combinations = []
+      next_steps_first.next_steps.each do |next_step|
+        combinations.push(
+          next_step.debug_report(index)
+        )
+      end
+      res_debug = {
+        "json_schema" => next_steps_first.to_hash,
+        "jsons" => res_logs,
+        "valid_jsons" => next_steps_first.logs,
+        "index_before" => next_steps_first.index_before - index,
+        "index_medium" => next_steps_first.index_medium - index,
+        "index_after" => next_steps_first.index_after - index,
+        "res_before" => next_steps_first.res_before.map{|r| r ? r : "null"}[index..-1],
+        "res_medium" => next_steps_first.res_medium.map{|r| r ? r : "null"}[index..-1],
+        "res_after" => next_steps_first.res_after.map{|r| r ? r : "null"}[index..-1],
+        "combinations" => combinations
+      }
+    end
+  end
+end

data/lib/fitting/doc/action.rb

@@ -0,0 +1,141 @@
+require 'fitting/doc/code'
+require 'fitting/debug'
+
+module Fitting
+  class Doc
+    class Action
+      attr_accessor :host, :prefix, :path, :method, :responses
+
+      class NotFound < RuntimeError; end
+
+      def initialize(host, prefix, method, path, responses)
+        @host = host
+        @prefix = prefix
+        @method = method
+        @path = path
+        @path.slice!(prefix)
+        @responses = []
+        responses.group_by { |response| response['status'] }.each do |code, value|
+          @responses.push(Code.new(code, value))
+        end
+        @key = "#{method} #{host}#{prefix}#{path}"
+
+        @host_cover = 0
+        @prefix_cover = 0
+        @path_cover = 0
+        @method_cover = 0
+      end
+
+      def to_hash_lock
+        res = YAML.dump(
+          {
+            host => {
+              prefix => {
+                path => {
+                  method => @responses.inject({}) { |sum, response| sum.merge!(response) }
+                }
+              }
+            }
+          }
+        ).split("\n")
+        { @key => res[1..-1] }
+      end
+
+      def to_hash
+        res = [
+          @host_cover,
+          @prefix_cover,
+          @path_cover,
+          @method_cover
+        ]
+        (to_hash_lock[@key].size - 4).times { res.push(nil) }
+
+        if @method_cover != nil && @method_cover != 0
+          code_index = 4
+          @responses.each do |code|
+            res, code_index = code.report(res, code_index)
+          end
+        end
+
+        { @key => res }
+      end
+
+      def cover!(log)
+        unless log.host == host
+          return
+        end
+        @host_cover += 1
+
+        unless prefix.size == 0 || log.path[0..prefix.size - 1] == prefix
+          return
+        end
+        @prefix_cover += 1
+
+        unless path_match(log.path)
+          return
+        end
+        @path_cover += 1
+
+        unless log.method == method
+          return
+        end
+        @method_cover += 1
+
+        @responses.each { |response| response.cover!(log) }
+
+        true
+      rescue Fitting::Doc::Code::NotFound => e
+        raise NotFound.new "\n\ntype: #{@type}\n"\
+          "host: #{@host}\n" \
+          "prefix: #{@prefix}\n" \
+          "method: #{@method}\n" \
+          "path: #{@path}\n" \
+          "#{e.message}"
+      end
+
+      def debug(debug)
+        unless debug.host == host
+          return nil
+        end
+
+        unless prefix.size == 0 || debug.path[0..prefix.size - 1] == prefix
+          return nil
+        end
+
+        unless path_match(debug.path)
+          return nil
+        end
+
+        unless debug.method == method
+          return nil
+        end
+
+        @responses.each do |response|
+          res = response.debug(debug)
+          return res if res
+        end
+        nil
+      end
+
+      def nocover!
+        @host_cover = nil
+        @prefix_cover = nil
+        @path_cover = nil
+        @method_cover = nil
+      end
+
+      def path_match(find_path)
+        regexp =~ find_path
+      end
+
+      def regexp
+        return @regexp if @regexp
+
+        str = Regexp.escape(@prefix + path)
+        str = str.gsub(/\\{\w+\\}/, '[^&=\/]+')
+        str = "\\A#{str}\\z"
+        @regexp = Regexp.new(str)
+      end
+    end
+  end
+end

data/lib/fitting/doc/code.rb

@@ -0,0 +1,53 @@
+require 'fitting/doc/step'
+require 'fitting/doc/content_type'
+
+module Fitting
+  class Doc
+    class Code < Step
+      class NotFound < RuntimeError; end
+
+      def initialize(code, value)
+        @step_cover_size = 0
+        @step_key = code
+        @next_steps = []
+        value.group_by { |val| val['content-type'] }.each do |content_type, subvalue|
+          break if content_type == nil
+          @next_steps.push(ContentType.new(content_type, subvalue))
+        end
+      end
+
+      def to_hash
+        if @next_steps.size == 1 && @next_steps[0].step_key == nil
+          {
+            @step_key => {}
+          }
+        else
+          {
+            @step_key => @next_steps.inject({}) { |sum, value| sum.merge!(value) }
+          }
+        end
+      end
+
+      def cover!(log)
+        if @step_key == log.status
+          @step_cover_size += 1
+          @next_steps.each { |content_type| content_type.cover!(log) }
+        end
+      rescue Fitting::Doc::ContentType::NotFound => e
+        raise NotFound.new "code: #{@step_key}\n\n"\
+          "#{e.message}"
+      end
+
+      def debug(debug)
+        if @step_key == debug.status
+          @next_steps.each do |content_type|
+            res = content_type.debug(debug)
+            return res if res
+          end
+          nil
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/fitting/doc/combination_enum.rb

@@ -0,0 +1,110 @@
+require 'fitting/doc/combination_step'
+require 'fitting/cover/json_schema_enum'
+
+module Fitting
+  class Doc
+    class CombinationEnum < CombinationStep
+      def cover!(log)
+        error = JSON::Validator.fully_validate(@json_schema, log.body)
+        if error == []
+          @step_cover_size += 1
+          @logs.push(log.body)
+          nil
+        else
+          bodies = custom_body(log.body)
+          errors = []
+          bodies.each do |body|
+            error = JSON::Validator.fully_validate(@json_schema, body)
+            if error == []
+              @step_cover_size += 1
+              @logs.push(body)
+              nil
+            else
+              errors.push(
+                {
+                  combination: @step_key,
+                  type: @type,
+                  json_schema: @json_schema,
+                  error: error,
+                  body: body
+                })
+            end
+          end
+
+          if errors.size == bodies.size
+            errors
+          else
+            nil
+          end
+        end
+      end
+
+      def find_keys
+        new_keys = []
+        if YAML.dump(@json_schema).include?("array")
+          res = @json_schema
+          @step_key.split('.').each do |key|
+            if res[key].class == Hash && res[key] != nil
+              if res[key].class == Hash && res[key]['type'] == 'array'
+                new_keys.push(key)
+                return new_keys
+              else
+                if key != 'properties'
+                  new_keys.push(key)
+                end
+                res = res[key]
+              end
+            end
+          end
+        end
+        []
+      end
+
+      def custom_body(body)
+        bodies = []
+        keys = find_keys
+        if keys != []
+          if keys.size == 1
+            if body[keys[0]].size == 1
+              return body
+            else
+              body[keys[0]].each do |bb|
+                new_body = body.dup
+                new_body.delete(keys[0])
+                bodies.push(new_body.merge(keys[0] => bb))
+              end
+            end
+          end
+          return bodies
+        end
+        [body]
+      end
+
+      def report(res, index)
+        @index_before = index
+        @res_before = [] + res
+        @index_medium = index
+        @res_medium = [] + res
+
+        combinations = @step_key.split('.')
+        elements = YAML.dump(@source_json_schema).split("\n")[1..-1]
+
+        res_index = 0
+        element_index = 0
+        elements.each_with_index do |element, i|
+          if element.include?(combinations[element_index])
+            element_index += 1
+          end
+          if combinations.size == element_index
+            res_index = i
+            break
+          end
+        end
+        res[res_index + index] = @step_cover_size
+        @index_after = res_index + index
+        @res_after = [] + res
+        [res, index]
+      end
+    end
+  end
+end

data/lib/fitting/doc/combination_one_of.rb

@@ -0,0 +1,61 @@
+require 'fitting/doc/combination_step'
+require 'fitting/cover/json_schema_enum'
+require 'fitting/doc/combination_enum'
+require 'fitting/cover/json_schema'
+require 'fitting/doc/combination_optional'
+
+module Fitting
+  class Doc
+    class CombinationOneOf < CombinationStep
+      def initialize_combinations(combination, json_schema)
+        combinations = Fitting::Cover::JSONSchemaEnum.new(@json_schema).combi
+        if combinations.size > 1
+          combinations.each do |comb|
+            @next_steps.push(CombinationEnum.new(comb[0], "#{comb[1][0]}", "#{comb[1][1]}", json_schema))
+          end
+        end
+
+        combinations = Fitting::Cover::JSONSchema.new(@json_schema).combi
+        combinations.each do |comb|
+          @next_steps.push(CombinationOptional.new(comb[0], "#{type}.#{comb[1][0]}", "#{combination}.#{comb[1][1]}", json_schema))
+        end
+      end
+
+      def cover!(log)
+        if JSON::Validator.fully_validate(@json_schema, log.body) == []
+          @step_cover_size += 1
+          @logs.push(log.body)
+          errors = @next_steps.inject([]) do |sum, combination|
+            sum.push(combination.cover!(log))
+          end.flatten.compact
+
+          return if @next_steps.size == 0
+          return unless @next_steps.size == errors.size
+
+          error_message = ""
+          errors.each do |error|
+            error_message += "combination: #{error[:combination]}\n"\
+            "combination type: #{error[:type]}\n"\
+            "combination json-schema: #{::JSON.pretty_generate(error[:json_schema])}\n"\
+            "combination error #{::JSON.pretty_generate(error[:error])}\n"\
+            "combination body #{::JSON.pretty_generate(error[:body])}\n"
+          end
+
+          # raise NotFound.new "#{error_message}\n"\
+          #  "source body: #{::JSON.pretty_generate(log.body)}"
+        end
+      end
+
+      def mark_range(index, res)
+        res[index + 1] = @step_cover_size
+        if @json_schema && @json_schema["required"]
+          mark_required(index + 1, res, @json_schema)
+        end
+      end
+
+      def index_offset
+        YAML.dump(@json_schema['properties']).split("\n").size +  YAML.dump(@json_schema['required']).split("\n").size
+      end
+    end
+  end
+end

data/lib/fitting/doc/combination_optional.rb

@@ -0,0 +1,54 @@
+require 'fitting/doc/combination_step'
+require 'fitting/cover/json_schema_enum'
+
+module Fitting
+  class Doc
+    class CombinationOptional < CombinationStep
+      def cover!(log)
+        error = JSON::Validator.fully_validate(@json_schema, log.body)
+        if error == []
+          @step_cover_size += 1
+          @logs.push(log.body)
+          nil
+        end
+      end
+
+      def report(res, index)
+        @index_before = index
+        @res_before = [] + res
+        @index_medium = index
+        @res_medium = [] + res
+
+        combinations = @step_key.split('.')
+        elements = YAML.dump(@source_json_schema).split("\n")[1..-1]
+        res_index = 0
+        elements.each_with_index do |element, i|
+          if element.include?(combinations[-1])
+            res_index = i
+            break
+          end
+        end
+
+        res[res_index + index] = @step_cover_size
+        res[res_index + index + 1] = @step_cover_size
+
+        if @source_json_schema["properties"][combinations[-1]] && @source_json_schema["properties"][combinations[-1]].class == Hash && @source_json_schema["properties"][combinations[-1]]["type"] == "array"
+          res[res_index + index + 2] = @step_cover_size
+          res[res_index + index + 3] = @step_cover_size
+          res[res_index + index + 4] = @step_cover_size
+
+          schema = @source_json_schema["properties"][combinations[-1]]['items']
+          mark_required(res_index + index + 4, res, schema)
+        elsif @source_json_schema["properties"][combinations[-1]] && @source_json_schema["properties"][combinations[-1]].class == Hash && @source_json_schema["properties"][combinations[-1]]["type"] == "object"
+          schema = @source_json_schema["properties"][combinations[-1]]
+          res[res_index + index + 2] = @step_cover_size
+          mark_required(res_index + index + 2, res, schema)
+        end
+
+        @index_after = res_index + index + 4
+        @res_after = [] + res
+        [res, index]
+      end
+    end
+  end
+end

data/lib/fitting/doc/combination_step.rb

@@ -0,0 +1,48 @@
+require 'fitting/doc/step'
+
+module Fitting
+  class Doc
+    class CombinationStep < Step
+      class NotFound < RuntimeError; end
+
+      attr_accessor :json_schema, :type, :logs
+
+      def initialize(json_schema, type, combination, source_json_schema)
+        @logs = []
+        @step_cover_size = 0
+        @json_schema = json_schema
+        @next_steps = []
+        @type = type
+        @step_key = combination
+        @source_json_schema = source_json_schema
+        initialize_combinations(combination, json_schema)
+      end
+
+      def initialize_combinations(combination, json_schema)
+      end
+
+      def debug_report(index)
+        combinations = []
+        @next_steps.each do |next_step|
+          combinations.push(
+            next_step.debug_report(index)
+          )
+        end
+        return {} if index.nil? || index_before.nil?
+        {
+          "combination type" => @type,
+          "combination" => @step_key,
+          "json_schema" => @json_schema,
+          "valid_jsons" => @logs,
+          "index_before" => @index_before - index,
+          "index_medium" => @index_medium - index,
+          "index_after" => @index_after - index,
+          "res_before" => @res_before.map { |r| r ? r : "null" }[index..-1],
+          "res_medium" => @res_medium.map { |r| r ? r : "null" }[index..-1],
+          "res_after" => @res_after.map { |r| r ? r : "null" }[index..-1],
+          "combinations" => combinations
+        }
+      end
+    end
+  end
+end