fitting 3.0.2 → 4.0.1

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

data/lib/fitting/doc/json_schema.rb

@@ -0,0 +1,112 @@
+require 'fitting/doc/step'
+require 'fitting/doc/combination_one_of'
+require 'fitting/cover/json_schema_one_of'
+require 'fitting/doc/combination_enum'
+require 'fitting/cover/json_schema_enum'
+require 'fitting/cover/json_schema'
+require 'fitting/doc/combination_optional'
+require 'json'
+require 'json-schema'
+
+module Fitting
+  class Doc
+    class JsonSchema < Step
+      class NotFound < RuntimeError; end
+
+      def initialize(json_schema, super_schema)
+        @super_schema = super_schema
+        @logs = []
+        @step_cover_size = 0
+        @step_key = json_schema
+        @next_steps = []
+        @oneOf = false
+        Fitting::Cover::JSONSchemaOneOf.new(json_schema).combi.each do |combination|
+          @oneOf = true
+          @next_steps.push(CombinationOneOf.new(combination[0], combination[1][0], combination[1][1], json_schema))
+        end
+        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
+
+        if json_schema['type'] != 'array'
+          combinations = Fitting::Cover::JSONSchema.new(json_schema).combi
+          combinations.each do |comb|
+            @next_steps.push(CombinationOptional.new(comb[0], comb[1][0], comb[1][1], json_schema))
+          end
+        end
+      end
+
+      def cover!(log)
+        if @super_schema
+          @step_cover_size += 1
+          @logs.push(log.body)
+          @next_steps.each { |combination| combination.cover!(log) }
+        elsif JSON::Validator.fully_validate(@step_key, log.body) == []
+          @step_cover_size += 1
+          @logs.push(log.body)
+          @next_steps.each { |combination| combination.cover!(log) }
+        else
+          raise Fitting::Doc::JsonSchema::NotFound.new "json-schema: #{::JSON.pretty_generate(@step_key)}\n\n"\
+            "body: #{::JSON.pretty_generate(log.body)}\n\n"\
+            "error #{::JSON.pretty_generate(JSON::Validator.fully_validate(@step_key, log.body))}"
+        end
+      rescue JSON::Schema::SchemaError => e
+        raise Fitting::Doc::JsonSchema::NotFound.new "json-schema: #{::JSON.pretty_generate(@step_key)}\n\n"\
+            "body: #{::JSON.pretty_generate(log.body)}\n\n"\
+            "error #{e.message}"
+      rescue Fitting::Doc::CombinationOneOf::NotFound => e
+        raise Fitting::Doc::JsonSchema::NotFound.new "#{e.message}\n\nsource json-schema: #{::JSON.pretty_generate(@step_key)}\n\n"
+      end
+
+      def logs
+        @logs
+      end
+
+      def mark_range(index, res)
+        start_index = index
+        end_index = start_index + 2
+
+        (start_index..end_index).each do |i|
+          res[i] = @step_cover_size
+        end
+
+        if @step_key["required"]
+          mark_required(end_index, res, @step_key)
+        end
+        end_index
+      end
+
+      def to_hash
+        @step_key
+      end
+
+      def report(res, index)
+        @index_before = index
+        @res_before = [] + res
+
+        index = mark_range(index, res)
+        @index_medium = index
+        @res_medium = [] + res
+
+        if @next_steps != []
+          new_index = index
+          @next_steps.each do |next_step|
+            if @oneOf
+              res, new_index = next_step.report(res, new_index)
+            else
+              res, new_index = next_step.report(res, @index_before)
+            end
+          end
+        end
+
+        index += index_offset
+        @index_after = index
+        @res_after = [] + res
+        [res, index]
+      end
+    end
+  end
+end

data/lib/fitting/doc/step.rb

@@ -0,0 +1,102 @@
+module Fitting
+  class Doc
+    class Step
+      attr_accessor :step_cover_size, :step_key, :next_steps, :index_before, :index_medium, :index_after, :res_before, :res_medium, :res_after
+
+      def to_hash
+        {
+          @step_key => @next_steps.inject({}) { |sum, value| sum.merge!(value) }
+        }
+      end
+
+      def nocover!
+        @step_cover_size = nil
+        @next_steps.each do |next_step|
+          next_step.nocover!
+        end
+      end
+
+      def report(res, index)
+        @index_before = index
+        @res_before = [] + res
+
+        mark_range(index, res)
+        @index_medium = index
+        @res_medium = [] + res
+
+        if @next_steps != []
+          new_index = index + new_index_offset
+          @next_steps.each do |next_step|
+            if self.class == Fitting::Doc::CombinationOneOf
+              res, _new_index = next_step.report(res, new_index - 2)
+            else
+              res, new_index = next_step.report(res, new_index)
+            end
+          end
+        end
+
+        index += index_offset
+        @index_after = index
+        @res_after = [] + res
+        [res, index]
+      end
+
+      def mark_range(index, res)
+        res[index] = @step_cover_size
+        if @json_schema && @json_schema["required"]
+          mark_required(index, res, @json_schema)
+        end
+      end
+
+      def new_index_offset
+        1
+      end
+
+      def index_offset
+        YAML.dump(@next_steps.inject({}) { |sum, value| sum.merge!(value) }).split("\n").size
+      end
+
+      def mark_required(index, res, schema)
+        start_index = index + YAML.dump(schema["properties"]).split("\n").size
+        end_index = start_index + YAML.dump(schema["required"]).split("\n").size - 1
+        (start_index..end_index).each do |i|
+          res[i] = @step_cover_size
+        end
+
+        return if schema["required"].nil?
+
+        schema["required"].each do |required|
+          required_index = YAML.dump(schema["properties"]).split("\n").index { |key| key == "#{required}:" }
+          break if required_index.nil?
+          res[index + required_index] = @step_cover_size
+          res[index + required_index + 1] = @step_cover_size
+          res[index + required_index + 2] = @step_cover_size if schema["properties"][required]["type"] == "string" && schema["properties"][required]["enum"]
+          if schema["properties"][required]["type"] == "object"
+            res[index + required_index + 2] = @step_cover_size
+            new_index = index + required_index + 2
+            mark_required(new_index, res, schema["properties"][required])
+          elsif schema["properties"][required]["type"] == "string" && schema["properties"][required]["enum"]
+            new_index = index + required_index + 2
+            mark_enum(new_index, res, schema["properties"][required])
+          end
+        end
+      end
+
+      def mark_enum(index, res, schema)
+        if schema["enum"].size == 1
+          res[index] = @step_cover_size
+          res[index + 1] = @step_cover_size
+        end
+      end
+
+      def valid?
+      end
+
+      def range
+      end
+
+      def next
+      end
+    end
+  end
+end

data/lib/fitting/doc.rb

@@ -0,0 +1,107 @@
+require 'fitting/doc/action'
+require 'tomograph'
+
+module Fitting
+  class Doc
+    class NotFound < RuntimeError; end
+
+    def self.all
+      apis = YAML.safe_load(File.read('.fitting.yml'))['APIs']
+      return [] unless apis
+      apis.map do |api|
+        if api['type'] == 'openapi2'
+          Tomograph::Tomogram.new(prefix: api['prefix'] || '', openapi2_json_path: api['path']).to_a.map do |action|
+            Fitting::Doc::Action.new(
+              api['host'],
+              api['prefix'] || '',
+              action.to_hash['method'],
+              action.to_hash['path'].path,
+              action.responses
+            )
+          end
+        elsif api['type'] == 'openapi3'
+          Tomograph::Tomogram.new(prefix: api['prefix'] || '', openapi3_yaml_path: api['path']).to_a.map do |action|
+            Fitting::Doc::Action.new(
+              api['host'],
+              api['prefix'] || '',
+              action.to_hash['method'],
+              action.to_hash['path'].path,
+              action.responses
+            )
+          end
+        elsif api['type'] == 'drafter'
+          Tomograph::Tomogram.new(prefix: api['prefix'] || '', drafter_yaml_path: api['path']).to_a.map do |action|
+            Fitting::Doc::Action.new(
+              api['host'],
+              api['prefix'] || '',
+              action.to_hash['method'],
+              action.to_hash['path'].path,
+              action.responses
+            )
+          end
+        elsif api['type'] == 'crafter'
+          Tomograph::Tomogram.new(prefix: api['prefix'] || '', crafter_yaml_path: api['path']).to_a.map do |action|
+            Fitting::Doc::Action.new(
+              api['host'],
+              api['prefix'] || '',
+              action.to_hash['method'],
+              action.to_hash['path'].path,
+              action.responses
+            )
+          end
+        elsif api['type'] == 'tomogram'
+          Tomograph::Tomogram.new(prefix: api['prefix'] || '', tomogram_json_path: api['path']).to_a.map do |action|
+            Fitting::Doc::Action.new(
+              api['host'],
+              api['prefix'] || '',
+              action.to_hash['method'],
+              action.to_hash['path'].path,
+              action.responses
+            )
+          end
+        end
+      end.flatten
+    end
+
+    def self.cover!(docs, log)
+      docs.each do |doc|
+        return if doc.cover!(log)
+      end
+      raise NotFound.new "log: #{log.method} #{log.host} #{log.url} #{log.status}"
+    rescue Fitting::Doc::Action::NotFound => e
+      raise NotFound.new "log error: #{e.message}"
+    end
+
+    def self.debug(docs, debug)
+      docs.each do |doc|
+        res = doc.debug(debug)
+        return res if res
+      end
+      raise NotFound
+    end
+
+    def self.report(actions)
+      all = 0
+      cov = 0
+      actions.each do |action|
+        action.to_hash.values.first.each do |cover_line|
+          if cover_line == nil
+            next
+          elsif cover_line == 0
+            all += 1
+          elsif cover_line > 0
+            all += 1
+            cov += 1
+          end
+        end
+      end
+      res = (cov.to_f / all.to_f * 100).round(2)
+      puts "Coverage: #{res}%"
+      if res == 100.00
+        exit 0
+      else
+        exit 1
+      end
+    end
+  end
+end

data/lib/fitting/host.rb

@@ -0,0 +1,37 @@
+module Fitting
+  class Host
+    class Skip < RuntimeError; end
+    class NotFound < RuntimeError
+      attr_reader :log
+      def initialize(msg, log)
+        @log = log
+        super(msg)
+      end
+    end
+
+    def initialize(host, skip)
+      @host = host
+      @skip = skip
+      @cover = false
+    end
+
+    def self.find!(log)
+      yaml = YAML.safe_load(File.read('.fitting.yml'))
+      yaml['hosts']&.map do |host|
+        if log.host == host.first.first
+          return new(host.first.first, host.first.last)
+        end
+      end
+      raise NotFound.new(log.host, log)
+    end
+
+    def cover!
+      @cover = true
+      raise Skip if @skip == 'skip'
+    end
+
+    def to_s
+      @host
+    end
+  end
+end

data/lib/fitting/log.rb

@@ -0,0 +1,102 @@
+module Fitting
+  class Log
+    def initialize(log, type)
+      @log = log
+      @type = type
+      @error = nil
+      @skip = false
+    end
+
+    def self.all
+      logs = []
+      Dir["log/fitting*.log"].each do |file_path|
+        testlog = File.read(file_path)
+        testlog.split("\n").select { |f| f.include?('incoming request ') }.each do |test|
+          logs.push(new(JSON.load(test.split('incoming request ')[1]), 'incoming'))
+        end
+        testlog.split("\n").select { |f| f.include?('outgoing request ') }.each do |test|
+          logs.push(new(JSON.load(test.split('outgoing request ')[1]), 'outgoing'))
+        end
+      end
+      logs.sort { |a, b| b.path <=> a.path }
+    end
+
+    def url
+      "#{host}#{path}"
+    end
+
+    def path
+      @log['path']
+    end
+
+    def method
+      @log['method']
+    end
+
+    def status
+      @log['response']['status'].to_s
+    end
+
+    def body
+      @log['response']['body']
+    end
+
+    def content_type
+      @log['response']['content_type']
+    end
+
+    def host
+      @log['host'] || 'www.example.com'
+    end
+
+    def type
+      @type
+    end
+
+    def access!
+      print "\e[32m.\e[0m"
+    end
+
+    def pending!
+      @skip = true
+      print "\e[33m*\e[0m"
+    end
+
+    def failure!(error)
+      @error = error
+      print "\e[31mF\e[0m"
+    end
+
+    def error
+      @error
+    end
+
+    def failure?
+      @error.present?
+    end
+
+    def self.failure(logs)
+      logs.select do |log|
+        log.failure?
+      end
+    end
+
+    def pending?
+      @skip
+    end
+
+    def self.pending(logs)
+      logs.select do |log|
+        log.pending?
+      end
+    end
+
+    def self.report(logs)
+      puts "\n\n"
+      Fitting::Log.failure(logs).each_with_index do |log, index|
+        puts "\e[31m  #{index + 1}) #{log.error.class} #{log.error.message}\n\n\e[0m"
+      end
+      print "\e[31m#{logs.size} examples, #{Fitting::Log.failure(logs).size} failure, #{Fitting::Log.pending(logs).size} pending\e[0m\n"
+    end
+  end
+end

data/lib/fitting/nocov.rb

@@ -0,0 +1,68 @@
+module Fitting
+  class NoCov
+    class NotFound < RuntimeError; end
+
+    def initialize(host, method, path, code, content_type, combination, combination_next)
+      @host = host
+      @method = method
+      @path = path
+      @code = code
+      @content_type = content_type
+      @combination = combination
+      @combination_next = combination_next
+    end
+
+    def self.all(yaml)
+      return [] unless yaml['NoCov']
+      yaml['NoCov'].map do |action|
+        new(action['host'], action['method'], action['path'], action['code'], action['content-type'], action['combination'], action['combination_next'])
+      end
+    end
+
+    def find(docs)
+      res = docs.find do |action|
+        action.host == @host && action.method == @method && action.path_match(@path)
+      end
+
+      if @code == nil
+        return res if res.present?
+        raise NotFound.new("host: #{@host}, method: #{@method}, path: #{@path}")
+      end
+
+      if res == nil
+        raise NotFound.new("host: #{@host}, method: #{@method}, path: #{@path}")
+      end
+
+      res_code = res.responses.find { |response| response.step_key == @code.to_s }
+
+      if @content_type == nil
+        return res_code if res_code.present?
+        raise NotFound.new("host: #{@host}, method: #{@method}, path: #{@path}, code: #{@code}")
+      end
+
+      res_content_type = res_code.next_steps.find { |content_type| content_type.step_key == @content_type.to_s }
+
+      if @combination == nil
+        return res_content_type if res_content_type.present?
+        raise NotFound.new("host: #{@host}, method: #{@method}, path: #{@path}, code: #{@code}, content-type: #{@content_type}")
+      end
+
+      res_json_schema = res_content_type.next_steps[0]
+      res_combination = res_json_schema.next_steps.find do |combination|
+        combination.step_key == @combination.to_s
+      end
+
+      if @combination_next == nil
+        return res_combination if res_combination
+        raise NotFound.new("host: #{@host}, method: #{@method}, path: #{@path}, code: #{@code}, content-type: #{@content_type}, combination: #{@combination}")
+      end
+
+      res_combination_next = res_combination.next_steps.find do |combination_next|
+        combination_next.step_key == @combination_next.to_s
+      end
+
+      return res_combination_next if res_combination_next
+      raise NotFound.new("host: #{@host}, method: #{@method}, path: #{@path}, code: #{@code}, content-type: #{@content_type}, combination: #{@combination}, combination_next: #{@combination_next}")
+    end
+  end
+end