fitting 2.18.3 → 3.0.0

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

data/lib/fitting/statistics/measurement_cover.rb

@@ -1,92 +0,0 @@
-module Fitting
-  class Statistics
-    class MeasurementCover
-      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.cover != 100
-          @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.cover != 100
-          @not_cover += 1
-        else
-          @cover += 1
-        end
-      end
-    end
-  end
-end

data/lib/fitting/statistics/measurement_cover_enum.rb

@@ -1,92 +0,0 @@
-module Fitting
-  class Statistics
-    class MeasurementCoverEnum
-      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.cover_enum != 100
-          @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.cover_enum != 100
-          @not_cover += 1
-        else
-          @cover += 1
-        end
-      end
-    end
-  end
-end

data/lib/fitting/statistics/measurement_cover_one_of.rb

@@ -1,92 +0,0 @@
-module Fitting
-  class Statistics
-    class MeasurementCoverOneOf
-      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.cover_one_of != 100
-          @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.cover_one_of != 100
-          @not_cover += 1
-        else
-          @cover += 1
-        end
-      end
-    end
-  end
-end

data/lib/fitting/statistics/not_covered_responses.rb

@@ -1,13 +0,0 @@
-module Fitting
-  class Statistics
-    class NotCoveredResponses
-      def initialize(measurement)
-        @measurement = measurement
-      end
-
-      def to_s
-        "#{@measurement.not_covered_responses.join("\n")}\n"
-      end
-    end
-  end
-end

data/lib/fitting/statistics/percent.rb

@@ -1,20 +0,0 @@
-module Fitting
-  class Statistics
-    class Percent
-      def initialize(divider, dividend)
-        @divider = divider
-        @dividend = dividend
-      end
-
-      def to_f
-        return 0.to_f if @divider.zero?
-
-        (@dividend.to_f / @divider * 100.0).round(2)
-      end
-
-      def to_s
-        "#{@dividend} (#{to_f}% of #{@divider})"
-      end
-    end
-  end
-end

data/lib/fitting/statistics/requests_stats.rb

@@ -1,40 +0,0 @@
-require 'fitting/statistics/percent'
-
-module Fitting
-  class Statistics
-    class RequestsStats
-      def initialize(measurement)
-        @measurement = measurement
-      end
-
-      def to_s
-        @to_s ||= [
-          "API requests with fully implemented responses: #{fully}.",
-          "API requests with partially implemented responses: #{partially}.",
-          "API requests with no implemented responses: #{non}."
-        ].join("\n")
-      end
-
-      def fully
-        @fully ||= Fitting::Statistics::Percent.new(
-          @measurement.requests.size,
-          @measurement.coverage_fully.size
-        )
-      end
-
-      def partially
-        @partially ||= Fitting::Statistics::Percent.new(
-          @measurement.requests.size,
-          @measurement.coverage_partially.size
-        )
-      end
-
-      def non
-        @non ||= Fitting::Statistics::Percent.new(
-          @measurement.requests.size,
-          @measurement.coverage_non.size
-        )
-      end
-    end
-  end
-end

data/lib/fitting/statistics/responses_stats.rb

@@ -1,32 +0,0 @@
-require 'fitting/statistics/percent'
-
-module Fitting
-  class Statistics
-    class ResponsesStats
-      def initialize(measurement)
-        @measurement = measurement
-      end
-
-      def to_s
-        @to_s ||= [
-          "API responses conforming to the blueprint: #{cover}.",
-          "API responses with validation errors or untested: #{not_cover}."
-        ].join("\n")
-      end
-
-      def cover
-        @cover ||= Fitting::Statistics::Percent.new(
-          @measurement.all_responses,
-          @measurement.cover_responses
-        )
-      end
-
-      def not_cover
-        @not_cover ||= Fitting::Statistics::Percent.new(
-          @measurement.all_responses,
-          @measurement.not_cover_responses
-        )
-      end
-    end
-  end
-end