fitting 2.18.3 → 3.0.0

data/lib/fitting/matchers/response_matcher.rb

@@ -1,88 +0,0 @@
-require 'fitting/response'
-require 'fitting/configuration'
-
-module Fitting
-  module Matchers
-    class Response
-      def matches?(response)
-        if Fitting.configuration.is_a?(Array)
-          Fitting.configuration.all? do |config|
-            one_match(response, config)
-          end
-        else
-          one_match(response, Fitting.configuration)
-        end
-      end
-
-      def ===(other)
-        matches?(other)
-      end
-
-      def failure_message
-        unless @response.documented?
-          return "response not documented\n"\
-                 "got: #{@response.real_request_with_status}"
-        end
-
-        return nil if @response.fully_validates.valid?
-
-        "response does not conform to json-schema\n"\
-          "schemas: \n#{@response.expected}\n\n"\
-          "got: #{@response.got}\n\n"\
-          "errors: \n#{@response.fully_validates}\n"
-      end
-
-      private
-
-      def one_match(response, config)
-        response = Fitting::Response.new(response, config.tomogram)
-        if response.within_prefix?(config.prefix)
-          @response = response
-          return true if @response.ignored?(config.ignore_list)
-
-          @response.fully_validates.valid?
-        else
-          true
-        end
-      end
-    end
-
-    class StrictResponse
-      def matches?(response)
-        if Fitting.configuration.is_a?(Array)
-          one_match(response, Fitting.configuration[0])
-        else
-          one_match(response, Fitting.configuration)
-        end
-      end
-
-      def ===(other)
-        matches?(other)
-      end
-
-      def failure_message
-        unless @response.documented?
-          return "response not documented\n"\
-                 "got: #{@response.real_request_with_status}"
-        end
-
-        return nil if @response.strict_fully_validates.valid?
-
-        "response does not conform to json-schema\n"\
-          "schemas: \n#{@response.expected}\n\n"\
-          "got: #{@response.got}\n\n"\
-          "errors: \n#{@response.strict_fully_validates}\n"
-      end
-
-      private
-
-      def one_match(response, config)
-        @response = Fitting::Response.new(
-          response,
-          config.tomogram
-        )
-        @response.strict_fully_validates.valid?
-      end
-    end
-  end
-end

data/lib/fitting/records/realized_unit.rb

@@ -1,52 +0,0 @@
-require 'fitting/records/test_unit/request'
-
-module Fitting
-  class Records
-    class RealizedUnit
-      def initialize(realized_requests, documented_requests)
-        @realized_requests = realized_requests
-        @documented_requests = documented_requests
-      end
-
-      def fully_covered?
-        all_good_documented = false
-        all_good_response_documented = false
-        all_good_response_json_schemas = false
-        all_good_valid_json_schemas = false
-
-        test_file_paths.each do |_key, requests|
-          all_good_documented = requests.all?(&:documented?)
-          all_good_response_documented = requests.all?(&:response_documented?)
-          all_good_response_json_schemas = requests.all?(&:response_json_schemas?)
-          all_good_valid_json_schemas = requests.all?(&:valid_json_schemas?)
-        end
-
-        all_good_documented && all_good_response_documented &&
-          all_good_response_json_schemas && all_good_valid_json_schemas
-      end
-
-      def test_file_paths
-        return @test_file_paths if @test_file_paths
-
-        @test_file_paths = {}
-        white_unit.map do |request|
-          @test_file_paths[request.test_file_path] ||= []
-          @test_file_paths[request.test_file_path].push(request)
-        end
-        @test_file_paths
-      end
-
-      def all_documented_requests
-        @all_documented_requests ||= @documented_requests.to_a.inject([]) do |res, tomogram_request|
-          res.push(Fitting::Records::Documented::Request.new(tomogram_request, nil))
-        end
-      end
-
-      def white_unit
-        @white_unit_requests ||= @realized_requests.to_a.inject([]) do |res, tested_request|
-          res.push(Fitting::Records::TestUnit::Request.new(tested_request, all_documented_requests))
-        end
-      end
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-require 'json-schema'
-
-module Fitting
-  class Records
-    class TestUnit
-      class Request
-        def initialize(tested_request, all_documented_requests)
-          @tested_request = tested_request
-          @all_documented_requests = all_documented_requests
-        end
-
-        def method
-          @method ||= @tested_request.method
-        end
-
-        def path
-          @path ||= @tested_request.path
-        end
-
-        def body
-          @body ||= @tested_request.body
-        end
-
-        def response
-          @response ||= @tested_request.response
-        end
-
-        def test_path
-          @test_path ||= @tested_request.title
-        end
-
-        def test_file_path
-          @test_file_path ||= @tested_request.group
-        end
-
-        def documented_requests
-          @documented_requests ||= @all_documented_requests.inject([]) do |res, documented_request|
-            next res unless @tested_request.method == documented_request.method &&
-                            documented_request.path.match(@tested_request.path.to_s)
-
-            res.push(documented_request)
-          end
-        end
-
-        def documented?
-          @documented ||= documented_requests.present?
-        end
-
-        def documented_responses
-          @documented_responses ||= documented_requests.inject([]) do |res, documented_request|
-            documented_request.responses.map do |documented_response|
-              next unless documented_response['status'] == response.status.to_s
-
-              res.push(documented_response)
-            end
-          end.flatten.compact
-        end
-
-        def response_documented?
-          @response_documented ||= documented_responses.present?
-        end
-
-        def response_json_schemas
-          @response_json_schemas ||= documented_responses.inject([]) do |res, documented_response|
-            res.push(documented_response['json_schemas'])
-          end.flatten
-        end
-
-        def response_json_schemas?
-          @response_json_schemas_present ||= response_json_schemas.present?
-        end
-
-        def valid_json_schemas
-          @valid_json_schemas ||= response_json_schemas.inject([]) do |res, json_schema|
-            next res unless JSON::Validator.validate(json_schema, response.body)
-
-            res.push(json_schema)
-          end.flatten
-        end
-
-        def invalid_json_schemas
-          @invalid_json_schemas ||= response_json_schemas.inject([]) do |res, json_schema|
-            next res if JSON::Validator.validate(json_schema, response.body)
-
-            res.push(
-              json_schema: json_schema,
-              fully_validate: JSON::Validator.fully_validate(json_schema, response.body)
-            )
-          end.flatten
-        end
-
-        def valid_json_schemas?
-          @valid_json_schemas_present ||= valid_json_schemas.present?
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-require 'json-schema'
-
-module Fitting
-  class Records
-    class Unit
-      class Combination
-        attr_reader :description, :json_schema, :bodies
-
-        def initialize(comb, bodies)
-          @description = comb[1]
-          @json_schema = comb[0]
-          @bodies = bodies
-        end
-
-        def valid_bodies
-          @valid_bodies ||= @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
-      end
-    end
-  end
-end

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