fitting 3.0.2 → 4.0.0

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

data/lib/fitting/doc/content_type.rb

@@ -0,0 +1,152 @@
+require 'fitting/doc/step'
+require 'fitting/doc/json_schema'
+
+module Fitting
+  class Doc
+    class ContentType < Step
+      class NotFound < RuntimeError; end
+
+      def initialize(content_type, subvalue)
+        @logs = []
+        @step_key = content_type
+        @next_steps = []
+        @step_cover_size = 0
+        return self if content_type != 'application/json'
+
+        definitions = subvalue.inject({}) do |sum, sv|
+          if sv['body']["definitions"] != nil
+            sum.merge!(sv['body'].delete('definitions'))
+          end
+          sum
+        end
+
+        if subvalue.size == 1
+          if definitions && definitions != {}
+            res = merge_definitions(subvalue[0], definitions)
+            if res && res['properties']['type'] == 'object'
+              @next_steps.push(JsonSchema.new(
+                {
+                  "$schema" => "http://json-schema.org/draft-04/schema#",
+                }.merge(res['properties']), false
+              ))
+            elsif res
+              @next_steps.push(JsonSchema.new(
+                {
+                  "$schema" => "http://json-schema.org/draft-04/schema#",
+                  "type" => "object"
+                }.merge(res), false
+              ))
+            else
+              @next_steps.push(JsonSchema.new({}, false))
+            end
+          else
+            @next_steps.push(JsonSchema.new(subvalue[0]['body'], false))
+          end
+        else
+          if definitions && definitions != {}
+            @next_steps.push(JsonSchema.new(
+              {
+                "$schema" => "http://json-schema.org/draft-04/schema#",
+                "type" => "object",
+                "oneOf" => subvalue.inject([]) do |sum, sv|
+                  res = merge_definitions(sv, definitions)
+                  sum.push(res)
+                end
+              }, false
+            ))
+          else
+            super_schema = false
+            subvalue.each do |sv|
+              super_schema = true if sv['body']["properties"] == nil
+            end
+
+            if super_schema
+              @next_steps.push(JsonSchema.new(
+                {
+                  "$schema" => "http://json-schema.org/draft-04/schema#",
+                  "type" => "object",
+                  "oneOf" => subvalue.inject([]) do |sum, sv|
+                    if sv['body']["properties"]
+                      sum.push(check_body(sv['body']["properties"], sv))
+                    end
+                    sum
+                  end
+                }, super_schema
+              ))
+            else
+              @next_steps.push(JsonSchema.new(
+                {
+                  "$schema" => "http://json-schema.org/draft-04/schema#",
+                  "type" => "object",
+                  "oneOf" => subvalue.inject([]) do |sum, sv|
+                    sum.push(check_body(sv['body']["properties"], sv))
+                  end
+                }, super_schema
+              ))
+              super_schema
+            end
+          end
+        end
+      end
+
+      def cover!(log)
+        if @step_key == log.content_type && log.content_type == 'application/json'
+          @step_cover_size += 1
+          @logs.push(log.body)
+          @next_steps.each { |json_schema| json_schema.cover!(log) }
+        elsif @step_key != 'application/json' && log.content_type != 'application/json'
+          @step_cover_size += 1
+        end
+      rescue Fitting::Doc::JsonSchema::NotFound => e
+        raise NotFound.new "content-type: #{@step_key}\n\n"\
+          "#{e.message}"
+      end
+
+      def debug(debug)
+        return self if @step_key == debug.content_type && debug.content_type == 'application/json'
+        nil
+      end
+
+      def logs
+        @logs
+      end
+
+      def merge_definitions(sv, definitions)
+        if sv['body']["properties"]
+          res = sv['body']["properties"]
+        elsif sv['body']['type'] != 'array'
+          res = sv['body']
+        end
+        definitions.each_pair do |key, value|
+          while JSON.dump(res).include?("\"$ref\":\"#/definitions/#{key}\"") do
+            new_res_array = JSON.dump(res).split('{')
+            index = new_res_array.index { |js| js.include?("\"$ref\":\"#/definitions/#{key}\"") }
+            if index != nil
+              def_size = "\"$ref\":\"#/definitions/#{key}\"".size
+              new_res_array[index] = JSON.dump(value)[1..-2] + new_res_array[index][def_size..-1]
+              res = JSON.load(new_res_array.join("{"))
+            end
+          end
+        end
+        if res == nil
+          nil
+        else
+          check_body(res, sv)
+        end
+      end
+
+      def check_body(res, sv)
+        if sv['body']["required"] == nil
+          {
+            "properties" => res
+          }
+        else
+          {
+            "properties" => res,
+            "required" => sv['body']["required"]
+          }
+        end
+      end
+    end
+  end
+end