fitting 3.0.1 → 4.0.0

data/lib/fitting/doc/json_schema.rb

@@ -0,0 +1,116 @@
+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 nocover!
+        @step_cover_size = nil
+      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(docs)
+      all = 0
+      cov = 0
+      docs.each do |provid|
+        provid.to_hash.values.first.each do |prov|
+          if prov == nil
+            break
+          elsif prov == 0
+            all += 1
+          elsif prov > 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,64 @@
+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
+
+      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

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