fitting 2.18.1 → 3.0.1

data/lib/fitting/records/unit/json_schema.rb

@@ -1,111 +0,0 @@
-require 'json-schema'
-require 'fitting/cover/json_schema'
-require 'fitting/cover/json_schema_enum'
-require 'fitting/cover/json_schema_one_of'
-require 'fitting/records/unit/combination'
-
-module Fitting
-  class Records
-    class Unit
-      class JsonSchema
-        attr_reader :json_schema
-
-        def initialize(json_schema, tested_bodies)
-          @json_schema = json_schema
-          @tested_bodies = tested_bodies
-        end
-
-        def bodies
-          @bodies ||= @tested_bodies.inject([]) do |res, tested_body|
-            next res unless JSON::Validator.validate(@json_schema, tested_body)
-
-            res.push(tested_body)
-          rescue JSON::Schema::UriError
-            res.push(tested_body)
-          end
-        end
-
-        def combinations
-          return @combinations if @combinations
-
-          @combinations = []
-          cover_json_schema = Fitting::Cover::JSONSchema.new(@json_schema)
-          cover_json_schema.combi.map do |comb|
-            @combinations.push(Fitting::Records::Unit::Combination.new(
-                                 comb,
-                                 bodies
-                               ))
-          end
-          @combinations
-        end
-
-        def combinations_with_enum
-          return @combinations_with_enum if @combinations_with_enum
-
-          @combinations_with_enum = []
-          qwe = Fitting::Cover::JSONSchema.new(@json_schema).combi +
-                Fitting::Cover::JSONSchemaEnum.new(@json_schema).combi
-          qwe.map do |comb|
-            @combinations_with_enum.push(Fitting::Records::Unit::Combination.new(
-                                           comb,
-                                           bodies
-                                         ))
-          end
-          @combinations_with_enum
-        end
-
-        def combinations_with_one_of
-          return @combinations_with_one_of if @combinations_with_one_of
-
-          @combinations_with_one_of = []
-          qwe = Fitting::Cover::JSONSchema.new(@json_schema).combi +
-                Fitting::Cover::JSONSchemaEnum.new(@json_schema).combi +
-                Fitting::Cover::JSONSchemaOneOf.new(@json_schema).combi
-          qwe.map do |comb|
-            @combinations_with_one_of.push(Fitting::Records::Unit::Combination.new(
-                                             comb,
-                                             bodies
-                                           ))
-          end
-          @combinations_with_one_of
-        end
-
-        def cover
-          @cover ||= if bodies == []
-                       0
-                     else
-                       count = 0
-                       combinations.map do |combination|
-                         count += 1 unless combination.valid_bodies == []
-                       end
-                       (count + 1) * 100 / (combinations.size + 1)
-                     end
-        end
-
-        def cover_enum
-          @cover_enum ||= if bodies == []
-                            0
-                          else
-                            count = 0
-                            combinations_with_enum.map do |combination|
-                              count += 1 unless combination.valid_bodies == []
-                            end
-                            (count + 1) * 100 / (combinations_with_enum.size + 1)
-                          end
-        end
-
-        def cover_one_of
-          @cover_one_of ||= if bodies == []
-                              0
-                            else
-                              count = 0
-                              combinations_with_one_of.map do |combination|
-                                count += 1 unless combination.valid_bodies == []
-                              end
-                              (count + 1) * 100 / (combinations_with_one_of.size + 1)
-                            end
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-require 'fitting/records/unit/response'
-
-module Fitting
-  class Records
-    class Unit
-      class Request
-        def initialize(documented_request, tested_requests)
-          @documented_request = documented_request
-          @tested_requests = tested_requests
-        end
-
-        def path
-          @path ||= @documented_request.path
-        end
-
-        def method
-          @method ||= @documented_request.method
-        end
-
-        def responses
-          @responses ||= @documented_request.responses.to_a.inject([]) do |res, documented_response|
-            res.push(Fitting::Records::Unit::Response.new(documented_response, tested_responses))
-          end
-        end
-
-        def tested_responses
-          @tested_responses ||= @tested_requests.to_a.inject([]) do |res, tested_request|
-            next res unless @documented_request.method == tested_request.method &&
-                            @documented_request.path.match(tested_request.path.to_s)
-
-            res.push(tested_request.response)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'fitting/records/unit/json_schema'
-
-module Fitting
-  class Records
-    class Unit
-      class Response
-        def initialize(documented_response, tested_responses)
-          @documented_response = documented_response
-          @tested_responses = tested_responses
-        end
-
-        def status
-          @status ||= @documented_response['status']
-        end
-
-        def json_schemas
-          @json_schemas ||= @documented_response['json_schemas'].inject([]) do |res, documented_json_schema|
-            res.push(Fitting::Records::Unit::JsonSchema.new(documented_json_schema, tested_bodies))
-          end
-        end
-
-        def tested_bodies
-          @tested_bodies ||= @tested_responses.inject([]) do |res, tested_response|
-            next res unless status == tested_response.status.to_s
-
-            res.push(tested_response.body)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fitting/request.rb

@@ -1,38 +0,0 @@
-require 'json-schema'
-
-module Fitting
-  class Request
-    def initialize(env_request, tomogram)
-      @method = env_request.request_method
-      @path = env_request.env['PATH_INFO'] || env_request.fullpath
-      @body = env_request.env['action_dispatch.request.request_parameters']
-      @schema = tomogram.find_request(method: @method, path: @path)
-    end
-
-    def route
-      "#{@schema.method}\t#{@schema.path}"
-    end
-
-    def real_method_with_path
-      "#{@method}\t#{@path}"
-    end
-
-    def schemas_of_possible_responses(status:)
-      return nil unless @schema
-
-      @schema.find_responses(status: status).map do |response|
-        response['body']
-      end
-    end
-
-    def within_prefix?(prefix)
-      @path.start_with?(prefix)
-    end
-
-    def ignored?(ignore_list)
-      ignore_list.any? do |regexp|
-        regexp.match(@path)
-      end
-    end
-  end
-end

data/lib/fitting/response/fully_validates.rb

@@ -1,34 +0,0 @@
-require 'json-schema'
-
-module Fitting
-  class Response
-    class FullyValidates < Array
-      def self.craft(schemas, body, strict)
-        if schemas
-          new(schemas.inject([]) do |res, schema|
-            res.push(fully_validate(schema, body, strict))
-          end)
-        else
-          @valid = false
-          new
-        end
-      end
-
-      def valid?
-        @valid ||= any? { |fully_validate| fully_validate == [] }
-      end
-
-      def to_s
-        @to_s ||= join("\n\n")
-      end
-
-      class << self
-        def fully_validate(schema, body, strict)
-          JSON::Validator.fully_validate(schema, body, strict: strict)
-        rescue JSON::Schema::UriError
-          []
-        end
-      end
-    end
-  end
-end

data/lib/fitting/response.rb

@@ -1,88 +0,0 @@
-require 'fitting/request'
-require 'fitting/response/fully_validates'
-require 'json'
-
-module Fitting
-  class Response
-    attr_reader :body
-
-    def initialize(env_response, tomogram)
-      @request = Fitting::Request.new(env_response.request, tomogram)
-      @status = env_response.status
-      @body = env_response.body
-      @schemas = @request.schemas_of_possible_responses(status: @status)
-    end
-
-    def within_prefix?(prefix)
-      @request.within_prefix?(prefix)
-    end
-
-    def fully_validates
-      @fully_validates ||= Fitting::Response::FullyValidates.craft(@schemas, @body, false)
-    end
-
-    def strict_fully_validates
-      @strict_fully_validates ||= Fitting::Response::FullyValidates.craft(@schemas, @body, true)
-    end
-
-    def documented?
-      @schemas&.present?
-    end
-
-    def route
-      index.map do |i|
-        "#{@request.route} #{@status} #{i}"
-      end
-    end
-
-    def strict_route
-      strict_index.map do |i|
-        "#{@request.route} #{@status} #{i}"
-      end
-    end
-
-    def real_request_with_status
-      "#{@request.real_method_with_path} #{@status}"
-    end
-
-    def got
-      JSON.pretty_generate(JSON.parse(@body))
-    end
-
-    def expected
-      @expected ||= @schemas.inject([]) do |res, schema|
-        res.push(JSON.pretty_generate(schema).to_s)
-      end.join("\n\n")
-    end
-
-    def json_schema
-      @schemas[index.first]
-    end
-
-    def ignored?(ignore_list)
-      @request.ignored?(ignore_list)
-    end
-
-    private
-
-    def index
-      return @index_res if @index_res
-
-      @index_res = []
-      @schemas.size.times do |i|
-        @index_res.push(i) if fully_validates[i] == []
-      end
-      @index_res
-    end
-
-    def strict_index
-      return @strict_index_res if @strict_index_res
-
-      @strict_index_res = []
-      @schemas.size.times do |i|
-        @strict_index_res.push(i) if strict_fully_validates[i] == []
-      end
-      @strict_index_res
-    end
-  end
-end

data/lib/fitting/statistics/analysis.rb

@@ -1,25 +0,0 @@
-require 'fitting/statistics/lists'
-require 'fitting/statistics/requests_stats'
-require 'fitting/statistics/responses_stats'
-require 'fitting/statistics/great'
-require 'fitting/statistics/not_covered_responses'
-
-module Fitting
-  class Statistics
-    class Analysis
-      def initialize(measurement, depth)
-        @measurement = measurement
-        @depth = depth
-      end
-
-      def to_s
-        [
-          Fitting::Statistics::Lists.new(@measurement, @depth).to_s,
-          Fitting::Statistics::RequestsStats.new(@measurement).to_s,
-          Fitting::Statistics::ResponsesStats.new(@measurement).to_s,
-          Fitting::Statistics::Great.new(@measurement).to_s
-        ].compact.join("\n\n")
-      end
-    end
-  end
-end

data/lib/fitting/statistics/cover_error.rb

@@ -1,29 +0,0 @@
-module Fitting
-  class Statistics
-    class CoverError
-      def initialize(request_unit)
-        @request_unit = request_unit
-      end
-
-      def to_s
-        res = ''
-        @request_unit.map do |request|
-          request.responses.map do |response|
-            next unless response.tested_bodies != []
-
-            response.json_schemas.map do |json_schema|
-              json_schema.combinations.map do |combination|
-                next unless combination.valid_bodies == []
-
-                res += "request method: #{request.method}\nrequest path: #{request.path}\n"\
-                        "response status: #{response.status}\nsource json-schema: #{json_schema.json_schema}\n"\
-                       "combination: #{combination.description}\nnew json-schema: #{combination.json_schema}\n\n"
-              end
-            end
-          end
-        end
-        res
-      end
-    end
-  end
-end

data/lib/fitting/statistics/cover_error_enum.rb

@@ -1,29 +0,0 @@
-module Fitting
-  class Statistics
-    class CoverErrorEnum
-      def initialize(request_unit)
-        @request_unit = request_unit
-      end
-
-      def to_s
-        res = ''
-        @request_unit.map do |request|
-          request.responses.map do |response|
-            next unless response.tested_bodies != []
-
-            response.json_schemas.map do |json_schema|
-              json_schema.combinations_with_enum.map do |combination|
-                next unless combination.valid_bodies == []
-
-                res += "request method: #{request.method}\nrequest path: #{request.path}\n"\
-                        "response status: #{response.status}\nsource json-schema: #{json_schema.json_schema}\n"\
-                       "combination: #{combination.description}\nnew json-schema: #{combination.json_schema}\n\n"
-              end
-            end
-          end
-        end
-        res
-      end
-    end
-  end
-end

data/lib/fitting/statistics/cover_error_one_of.rb

@@ -1,29 +0,0 @@
-module Fitting
-  class Statistics
-    class CoverErrorOneOf
-      def initialize(request_unit)
-        @request_unit = request_unit
-      end
-
-      def to_s
-        res = ''
-        @request_unit.map do |request|
-          request.responses.map do |response|
-            next unless response.tested_bodies != []
-
-            response.json_schemas.map do |json_schema|
-              json_schema.combinations_with_one_of.map do |combination|
-                next unless combination.valid_bodies == []
-
-                res += "request method: #{request.method}\nrequest path: #{request.path}\n"\
-                        "response status: #{response.status}\nsource json-schema: #{json_schema.json_schema}\n"\
-                       "combination: #{combination.description}\nnew json-schema: #{combination.json_schema}\n\n"
-              end
-            end
-          end
-        end
-        res
-      end
-    end
-  end
-end

data/lib/fitting/statistics/great.rb

@@ -1,13 +0,0 @@
-module Fitting
-  class Statistics
-    class Great
-      def initialize(measurement)
-        @measurement = measurement
-      end
-
-      def to_s
-        return 'All responses are 100% valid! Great job!' if @measurement.cover_responses == @measurement.all_responses
-      end
-    end
-  end
-end

data/lib/fitting/statistics/list.rb

@@ -1,55 +0,0 @@
-module Fitting
-  class Statistics
-    class List
-      def initialize(coverage, max_response_path, depth)
-        @coverage = coverage
-        @max_response_path = max_response_path
-        @depth = depth
-      end
-
-      def to_s
-        list_sort.inject([]) do |res, request|
-          res.push("#{request.method}\t#{request.path}#{responses_stat(request)}")
-        end.join("\n")
-      end
-
-      def list_sort
-        @coverage.sort do |first, second|
-          first.path.to_s <=> second.path.to_s
-        end
-      end
-
-      def responses_stat(request)
-        tab = "\t" * ((@max_response_path - request.path.to_s.size / 8) + 3)
-        tab + request.responses.to_a.each_with_object([]) do |response, res|
-          response_stat(response, res)
-        end.join(' ')
-      end
-
-      private
-
-      def response_stat(response, res)
-        response.json_schemas.map do |json_schema|
-          json_schema_stat(res, json_schema, response)
-        end
-      end
-
-      def json_schema_stat(res, json_schema, response)
-        case @depth
-        when 'valid'
-          if json_schema.bodies == []
-            res.push("✖ #{response.status}")
-          else
-            res.push("✔ #{response.status}")
-          end
-        when 'cover'
-          res.push("#{json_schema.cover}% #{response.status}")
-        when 'cover_enum'
-          res.push("#{json_schema.cover_enum}% #{response.status}")
-        when 'cover_one_of'
-          res.push("#{json_schema.cover_one_of}% #{response.status}")
-        end
-      end
-    end
-  end
-end

data/lib/fitting/statistics/lists.rb

@@ -1,53 +0,0 @@
-require 'fitting/statistics/list'
-
-module Fitting
-  class Statistics
-    class Lists
-      def initialize(measurement, depth)
-        @measurement = measurement
-        @depth = depth
-      end
-
-      def to_s
-        [
-          coverage_fully_stat,
-          coverage_partially_stat,
-          coverage_non_stat
-        ].compact.join("\n\n")
-      end
-
-      def coverage_fully_stat
-        if @measurement.coverage_fully == []
-          nil
-        else
-          [
-            'Fully conforming requests:',
-            Fitting::Statistics::List.new(@measurement.coverage_fully, @measurement.max_response_path, @depth).to_s
-          ].join("\n")
-        end
-      end
-
-      def coverage_partially_stat
-        if @measurement.coverage_partially == []
-          nil
-        else
-          [
-            'Partially conforming requests:',
-            Fitting::Statistics::List.new(@measurement.coverage_partially, @measurement.max_response_path, @depth).to_s
-          ].join("\n")
-        end
-      end
-
-      def coverage_non_stat
-        if @measurement.coverage_non == []
-          nil
-        else
-          [
-            'Non-conforming requests:',
-            Fitting::Statistics::List.new(@measurement.coverage_non, @measurement.max_response_path, @depth).to_s
-          ].join("\n")
-        end
-      end
-    end
-  end
-end

data/lib/fitting/statistics/measurement.rb

@@ -1,92 +0,0 @@
-module Fitting
-  class Statistics
-    class Measurement
-      attr_reader :requests, :all_responses, :cover_responses, :not_cover_responses, :max_response_path,
-                  :coverage_fully, :coverage_non, :coverage_partially, :not_covered_responses
-
-      def initialize(requests)
-        @requests = requests
-        @all_responses = 0
-        @cover_responses = 0
-        @not_cover_responses = 0
-        @max_response_path = 0
-        @coverage_fully = []
-        @coverage_non = []
-        @coverage_partially = []
-        @not_covered_responses = []
-        check_responses
-      end
-
-      def check_responses
-        return if @ready
-
-        @requests.map do |request|
-          chech_request(request)
-        end
-
-        @ready = true
-      end
-
-      private
-
-      def chech_request(request)
-        check_cover(request)
-        coverage_push(request)
-
-        @max_response_path = request.path.to_s.size / 8 if request.path.to_s.size / 8 > @max_response_path
-        request.responses.map do |response|
-          check_response(response, request)
-        end
-      end
-
-      def check_response(response, request)
-        json_schema_index = 0
-        response.json_schemas.map do |json_schema|
-          json_schema_index = check_json_schema(json_schema, request, response, json_schema_index)
-        end
-      end
-
-      def check_json_schema(json_schema, request, response, json_schema_index)
-        if json_schema.bodies == []
-          @not_cover_responses += 1
-          @not_covered_responses.push("#{request.method}\t#{request.path} #{response.status} #{json_schema_index}")
-        else
-          @cover_responses += 1
-        end
-        @all_responses += 1
-        json_schema_index + 1
-      end
-
-      def coverage_push(request)
-        if @all == @cover
-          @coverage_fully.push(request)
-        elsif @all == @not_cover
-          @coverage_non.push(request)
-        else
-          @coverage_partially.push(request)
-        end
-      end
-
-      def check_cover(request)
-        @all = 0
-        @cover = 0
-        @not_cover = 0
-
-        request.responses.map do |response|
-          response.json_schemas.map do |json_schema|
-            count_cover(json_schema)
-          end
-        end
-      end
-
-      def count_cover(json_schema)
-        @all += 1
-        if json_schema.bodies == []
-          @not_cover += 1
-        else
-          @cover += 1
-        end
-      end
-    end
-  end
-end