fitting 2.13.1 → 2.16.1

data/fitting.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['d.efimov']
   spec.email         = ['d.efimov@fun-box.ru']
 
-  spec.summary       = 'Validation in the rspec of API Blueprint'
-  spec.description   = 'Validation responses in the rspec with the help of API Blueprint'
+  spec.summary       = 'Coverage API Blueprint, Swagger and OpenAPI with rspec tests'
+  spec.description   = 'Coverage API Blueprint, Swagger and OpenAPI with rspec tests for easily make high-quality API and documenatiton.'
   spec.homepage      = 'https://github.com/funbox/fitting'
   spec.license       = 'MIT'
 
@@ -20,8 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'json-schema', '~> 2.6', '>= 2.6.2'
   spec.add_runtime_dependency 'multi_json', '~> 1.11'
-  spec.add_runtime_dependency 'tomograph', '~> 2.0', '>= 2.2.0'
-  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_runtime_dependency 'tomograph', '~> 3.1', '>= 3.1.0'
+  spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'byebug', '~> 8.2', '>= 8.2.1'
   spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.4', '>= 3.4.0'

data/lib/fitting/records/spherical/requests.rb

@@ -13,7 +13,9 @@ module Fitting
             array += JSON.load(File.read(file))
           end
           @to_a = array.inject([]) do |res, tested_request|
-            res.push(Fitting::Records::Spherical::Request.load(tested_request))
+            request = Fitting::Records::Spherical::Request.load(tested_request)
+            next res unless request.path.to_s.start_with?(Fitting.configuration.prefix)
+            res.push(request)
           end
         end
       end

data/lib/fitting/report/action.rb

@@ -0,0 +1,53 @@
+require 'fitting/report/responses'
+
+module Fitting
+  module Report
+    class Action
+      def initialize(action)
+        @action = action
+        @tests = Fitting::Report::Tests.new([])
+        @responses = Fitting::Report::Responses.new(@action.responses)
+      end
+
+      def method
+        @action.method
+      end
+
+      def path
+        @action.path.to_s
+      end
+
+      def responses
+        @responses
+      end
+
+      def add_test(test)
+        @tests.push(test)
+      end
+
+      def path_match(find_path)
+        regexp =~ find_path
+      end
+
+      def regexp
+        return @regexp if @regexp
+
+        str = Regexp.escape(path)
+        str = str.gsub(/\\{\w+\\}/, '[^&=\/]+')
+        str = "\\A#{str}\\z"
+        @regexp = Regexp.new(str)
+      end
+
+      def tests
+        @tests
+      end
+
+      def details
+        {
+            tests_without_responses: @tests.without_responses,
+            responses_details: @responses.to_a.map { |r| {method: r.status, tests_size: r.tests.size, json_schema: r.id, combinations: r.details} }
+        }
+      end
+    end
+  end
+end

data/lib/fitting/report/actions.rb

@@ -0,0 +1,51 @@
+require 'fitting/report/action'
+
+module Fitting
+  module Report
+    class Actions
+      def initialize(actions)
+        @actions = []
+        actions.to_a.map do |action|
+          @actions.push(Fitting::Report::Action.new(action))
+        end
+      end
+
+      def to_a
+        @actions
+      end
+
+      def join(tests)
+        tests.to_a.map do |test|
+          if is_there_a_suitable_action?(test)
+            cram_into_the_appropriate_action(test)
+            test.mark_action
+          end
+        end
+      end
+
+      def is_there_a_suitable_action?(test)
+        @actions.map do |action|
+          return true if test.method == action.method && action.path_match(test.path)
+        end
+
+        false
+      end
+
+      def cram_into_the_appropriate_action(test)
+        @actions.map do |action|
+          if test.method == action.method && action.path_match(test.path)
+            action.add_test(test)
+            return
+          end
+        end
+      end
+
+      def details(prefix)
+        {
+            tests_without_actions: prefix.tests.without_actions,
+            actions_details: @actions.map { |a| {method: a.method, path: a.path, tests_size: a.tests.size, responses: a.details} }
+        }
+      end
+    end
+  end
+end

data/lib/fitting/report/combination.rb

@@ -0,0 +1,37 @@
+module Fitting
+  module Report
+    class Combination
+      def initialize(json_schema:, type:, combination:)
+        @json_schema = json_schema
+        @type = type
+        @combination = combination
+        @tests = Fitting::Report::Tests.new([])
+        @id = SecureRandom.hex
+      end
+
+      def json_schema
+        @json_schema
+      end
+
+      def id
+        @id
+      end
+
+      def type
+        @type
+      end
+
+      def name
+        @combination
+      end
+
+      def tests
+        @tests
+      end
+
+      def add_test(test)
+        @tests.push(test)
+      end
+    end
+  end
+end

data/lib/fitting/report/combinations.rb

@@ -0,0 +1,47 @@
+module Fitting
+  module Report
+    class Combinations
+      def initialize(combinations)
+        @combinations = combinations
+      end
+
+      def to_a
+        @combinations
+      end
+
+      def size
+        @combinations.size
+      end
+
+      def size_with_tests
+        @combinations.count { |c| c.tests.size != 0 }
+      end
+
+      def join(tests)
+        tests.to_a.map do |test|
+          if is_there_a_suitable_combination?(test)
+            cram_into_the_appropriate_combinations(test)
+            test.mark_combination
+          end
+        end
+      end
+
+      def is_there_a_suitable_combination?(test)
+        return false if @combinations.nil?
+        @combinations.map do |combination|
+          return true if JSON::Validator.fully_validate(combination.json_schema, test.body) == []
+        end
+
+        false
+      end
+
+      def cram_into_the_appropriate_combinations(test)
+        @combinations.map do |combination|
+          if JSON::Validator.fully_validate(combination.json_schema, test.body) == []
+            combination.add_test(test)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fitting/report/console.rb

@@ -0,0 +1,41 @@
+module Fitting
+  module Report
+    class Console
+      def initialize(tests_without_prefixes, prefixes_details)
+        @tests_without_prefixes = tests_without_prefixes
+        @prefixes_details = prefixes_details
+        @good = true
+        @tests_without_actions = []
+        @tests_without_responses = []
+      end
+
+      def output
+        doc_res = @prefixes_details.inject('') do |res, prefix_details|
+          res += "#{prefix_details[:name]}\n"
+          @tests_without_actions += prefix_details[:actions][:tests_without_actions]
+          res += prefix_details[:actions][:actions_details].inject('') do |res_actions, action|
+            res_actions += "#{action[:method]}\t#{action[:path]}"
+            tab = "\t" * (8 - action[:path].size / 8)
+            @tests_without_responses += action[:responses][:tests_without_responses]
+            res_actions += tab + action[:responses][:responses_details].inject('') do |res_responses, response|
+              @good = false if response[:combinations][:cover_percent] != '100%'
+              res_responses += " #{response[:combinations][:cover_percent]} #{response[:method]}"
+            end
+            res_actions += "\n"
+          end
+        end
+        doc_res += "\n"
+        doc_res += "tests_without_prefixes: #{@tests_without_prefixes.size}\n"
+        doc_res += "tests_without_actions: #{@tests_without_actions.size}\n"
+        doc_res += "tests_without_responses: #{@tests_without_responses.size}\n"
+      end
+
+      def good?
+        return false if @tests_without_prefixes.size != 0
+        return false if @tests_without_actions.size != 0
+        return false if @tests_without_responses.size != 0
+        @good
+      end
+    end
+  end
+end

data/lib/fitting/report/prefix.rb

@@ -0,0 +1,88 @@
+require 'fitting/report/actions'
+
+module Fitting
+  module Report
+    class Prefix
+      def initialize(name: '', openapi2_json_path: nil, openapi3_yaml_path: nil, drafter_yaml_path: nil, tomogram_json_path: nil, crafter_yaml_path: nil, skip: false)
+        @name = name
+        @tomogram_json_path = tomogram_json_path
+        @tests = Fitting::Report::Tests.new([])
+        @skip = skip
+        unless skip
+          @actions = if openapi2_json_path
+                       Fitting::Report::Actions.new(
+                         Tomograph::Tomogram.new(
+                           prefix: name,
+                           openapi2_json_path: openapi2_json_path
+                         )
+                       )
+                     elsif openapi3_yaml_path
+                       Fitting::Report::Actions.new(
+                         Tomograph::Tomogram.new(
+                           prefix: name,
+                           openapi3_yaml_path: openapi3_yaml_path
+                         )
+                       )
+                     elsif drafter_yaml_path
+                       Fitting::Report::Actions.new(
+                         Tomograph::Tomogram.new(
+                           prefix: name,
+                           drafter_yaml_path: drafter_yaml_path
+                         )
+                       )
+                     elsif crafter_yaml_path
+                       Fitting::Report::Actions.new(
+                         Tomograph::Tomogram.new(
+                           prefix: name,
+                           crafter_yaml_path: crafter_yaml_path
+                         )
+                       )
+                     else
+                       Fitting::Report::Actions.new(
+                         Tomograph::Tomogram.new(
+                           prefix: name,
+                           tomogram_json_path: tomogram_json_path
+                         )
+                       )
+                     end
+        end
+      end
+
+      def name
+        @name
+      end
+
+      def tests
+        @tests
+      end
+
+      def skip?
+        @skip
+      end
+
+      def actions
+        @actions
+      end
+
+      def details
+        if @skip
+          {
+              name: @name,
+              tests_size: @tests.size,
+              actions: {tests_without_actions: [], actions_details: []}
+          }
+        else
+          {
+              name: @name,
+              tests_size: @tests.size,
+              actions: @actions.details(self)
+          }
+        end
+      end
+
+      def add_test(test)
+        @tests.push(test)
+      end
+    end
+  end
+end

data/lib/fitting/report/prefixes.rb

@@ -0,0 +1,56 @@
+require 'fitting/report/prefix'
+
+module Fitting
+  module Report
+    class Prefixes
+      def initialize(config_path)
+        @prefixes = []
+        YAML.safe_load(File.read(config_path))['prefixes'].map do |prefix|
+          @prefixes.push(
+            Fitting::Report::Prefix.new(
+              name: prefix['name'],
+              openapi2_json_path: prefix['openapi2_json_path'],
+              openapi3_yaml_path: prefix['openapi3_yaml_path'],
+              drafter_yaml_path: prefix['drafter_yaml_path'],
+              tomogram_json_path: prefix['tomogram_json_path'],
+              crafter_yaml_path: prefix['crafter_yaml_path'],
+              skip: prefix['skip']
+            )
+          )
+        end
+      end
+
+      def is_there_a_suitable_prefix?(test_path)
+        @prefixes.map do |prefix|
+          return true if prefix.name.nil?
+          return true if prefix.name == ''
+          return true if test_path[0..prefix.name.size - 1] == prefix.name
+        end
+
+        false
+      end
+
+      def cram_into_the_appropriate_prefix(test)
+        @prefixes.map do |prefix|
+          if prefix.name.nil? || prefix.name == '' || test.path[0..prefix.name.size - 1] == prefix.name
+            prefix.add_test(test)
+            return
+          end
+        end
+      end
+
+      def join(tests)
+        tests.to_a.map do |test|
+          if is_there_a_suitable_prefix?(test.path)
+            cram_into_the_appropriate_prefix(test)
+            test.mark_prefix
+          end
+        end
+      end
+
+      def to_a
+        @prefixes
+      end
+    end
+  end
+end

data/lib/fitting/report/response.rb

@@ -0,0 +1,71 @@
+require 'fitting/statistics/template_cover_error'
+require 'fitting/statistics/template_cover_error_enum'
+require 'fitting/statistics/template_cover_error_one_of'
+require 'fitting/report/combinations'
+require 'fitting/report/combination'
+
+module Fitting
+  module Report
+    class Response
+      def initialize(response)
+        @response = response
+        @tests = Fitting::Report::Tests.new([])
+        @id = SecureRandom.hex
+      end
+
+      def status
+        @response['status'] || @response[:status]
+      end
+
+      def body
+        @response['body'] || @response[:body]
+      end
+
+      def id
+        @id
+      end
+
+      def add_test(test)
+        @tests.push(test)
+      end
+
+      def tests
+        @tests
+      end
+
+      def combinations
+        return @combinations if @combinations
+
+        cmbntns = []
+        combinations = Fitting::Cover::JSONSchema.new(body).combi + Fitting::Cover::JSONSchemaEnum.new(body).combi + Fitting::Cover::JSONSchemaOneOf.new(body).combi
+        if combinations != []
+          combinations.map do |combination|
+            cmbntns.push(
+                Fitting::Report::Combination.new(
+                    json_schema: combination[0],
+                    type: combination[1][0],
+                    combination: combination[1][1]
+                )
+            )
+          end
+        end
+
+        @combinations = Fitting::Report::Combinations.new(cmbntns)
+      end
+
+      def cover_percent
+        return '0%' if @tests.size == 0
+        return '100%' if @combinations.size == 0
+        "#{(@combinations.size_with_tests + 1) * 100 / (@combinations.size + 1)}%"
+      end
+
+      def details
+        {
+            cover_percent: cover_percent,
+            tests_without_combinations: @tests.without_combinations,
+            combinations_details: @combinations.to_a.map { |c| {json_schema: c.id, tests_size: c.tests.size, type: c.type, name: c.name} }
+        }
+      end
+    end
+  end
+end