fitting 2.12.1 → 2.15.0

data/fitting.gemspec

@@ -20,10 +20,10 @@ 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.0', '>= 3.0.0'
+  spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'byebug', '~> 8.2', '>= 8.2.1'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.4', '>= 3.4.0'
   spec.add_development_dependency 'rubocop', '~> 0.49.1', '>= 0.49.1'
   spec.add_development_dependency 'simplecov', '~> 0.11', '>= 0.11.2'

data/lib/fitting.rb

@@ -16,6 +16,7 @@ module Fitting
     end
 
     def statistics
+      puts 'DEPRECATED: deprecated method statistics, use new method save_test_data'
       responses = Fitting::Storage::Responses.new
 
       RSpec.configure do |config|
@@ -35,6 +36,10 @@ module Fitting
       FileUtils.rm_r Dir.glob("fitting_tests/*"), :force => true
 
       RSpec.configure do |config|
+        config.after(:each, type: :request) do
+          responses.add(response, inspect)
+        end
+
         config.after(:each, type: :controller) do
           responses.add(response, inspect)
         end

data/lib/fitting/cover/json_schema.rb

@@ -3,95 +3,36 @@ module Fitting
     class JSONSchema
       def initialize(json_schema)
         @json_schema = json_schema
+        @combinations = []
       end
 
       def combi
-        return @combinations if @combinations
-        @combinations = new_required(@json_schema)
-
-        return @combinations unless @json_schema['properties']
-        @combinations = new_super_each(@json_schema['properties'], { 'properties' => nil }, @json_schema, @combinations, 'properties')
-
-        @combinations
-      end
-
-      def new_super_each(json_schema, old_keys_hash, lol_schema, combinations, old_key)
-        json_schema.each do |key, value|
-          next unless value.is_a?(Hash)
-
-          new_keys_hash = clone_hash(old_keys_hash)
-          add_super_key(new_keys_hash, key)
-
-          combinations = new_super_each(value, new_keys_hash, lol_schema, combinations, [old_key, key].compact.join('.'))
-
-          qwe = new_required(value)
-          qwe.map do |asd|
-            new_json_shema = clone_hash(lol_schema)
-            super_merge(new_keys_hash, asd[0], new_json_shema)
-            combinations.push([new_json_shema, [asd[1][0], [old_key, key, asd[1][1]].compact.join('.')]])
-          end
-        end
-        combinations
-      end
-
-      def add_super_key(vbn, new_key)
-        vbn.each do |key, value|
-          if value
-            add_super_key(value, new_key)
-          else
-            vbn[key] = { new_key => nil }
-          end
+        inception(@json_schema, @combinations).each do |combination|
+          combination[0] = @json_schema.merge(combination[0])
+          combination[1] = ['required', combination[1]]
         end
       end
 
-      def super_merge(vbn, asd, old_json_schema)
-        vbn.each do |key, value|
-          if value
-            super_merge(value, asd, old_json_schema[key])
-          else
-            old_json_schema[key].merge!(asd)
-          end
-        end
-        old_json_schema
-      end
-
-      def clone_hash(old_json_schema)
-        new_json_schema = {}
-        old_json_schema.each do |key, value|
-          if value.is_a?(Hash)
-            new_json_schema.merge!(key => clone_hash(value))
-          elsif value
-            new_json_schema.merge!(key => value.clone)
-          else
-            new_json_schema.merge!(key => nil)
-          end
-        end
-        new_json_schema
-      end
-
-      def new_required(json_schema)
-        res = []
-        new_keys(json_schema).map do |new_key|
-          new_json_shema = json_schema.dup
-          if new_json_shema['required']
-            new_json_shema['required'] += [new_key]
-          else
-            new_json_shema['required'] = [new_key]
+      def inception(json_schema, combinations)
+        json_schema.each do |key, value|
+          if key == 'properties' and json_schema['required'] != value.keys
+            schema = json_schema.dup
+            one_of = schema.delete('required') || []
+            schema['properties'].each_key do |property|
+              next if one_of.include?(property)
+              combinations.push([schema.merge('required' => one_of + [property]), "required.#{property}"])
+            end
+          elsif value.is_a?(Hash)
+            com = inception(value, [])
+            com.each do |combination|
+              combination[0] = { key => value.merge(combination[0])}
+              combination[1] = "#{key}.#{combination[1]}"
+            end
+            combinations += com
           end
-          res.push([new_json_shema, ['required', new_key]])
         end
-        res
-      end
 
-      def new_keys(json_schema)
-        return [] unless json_schema && json_schema['properties']
-        all = json_schema['properties'].keys.map(&:to_s)
-        old = json_schema['required']
-        if old
-          all - old
-        else
-          all
-        end
+        combinations
       end
     end
   end

data/lib/fitting/cover/json_schema_enum.rb

@@ -3,85 +3,35 @@ module Fitting
     class JSONSchemaEnum
       def initialize(json_schema)
         @json_schema = json_schema
-      end
-
-      def combi
-        return @combinations if @combinations
         @combinations = []
-
-        return @combinations unless @json_schema['properties']
-        @combinations = new_super_each(@json_schema['properties'], { 'properties' => nil }, @json_schema, @combinations, 'properties')
-
-        @combinations
-      end
-
-      def new_super_each(json_schema, old_keys_hash, lol_schema, combinations, old_key)
-        json_schema.each do |key, value|
-          next unless value.is_a?(Hash)
-
-          new_keys_hash = clone_hash(old_keys_hash)
-          add_super_key(new_keys_hash, key)
-
-          combinations = new_super_each(value, new_keys_hash, lol_schema, combinations, [old_key, key].compact.join('.'))
-
-          qwe = new_enum(value)
-          qwe.map do |asd|
-            new_json_shema = clone_hash(lol_schema)
-            super_merge(new_keys_hash, asd[0], new_json_shema)
-            combinations.push([new_json_shema, [asd[1][0], [old_key, key, asd[1][1]].compact.join('.')]])
-          end
-        end
-        combinations
       end
 
-      def add_super_key(vbn, new_key)
-        vbn.each do |key, value|
-          if value
-            add_super_key(value, new_key)
-          else
-            vbn[key] = { new_key => nil }
-          end
-        end
-      end
-
-      def super_merge(vbn, asd, old_json_schema)
-        vbn.each do |key, value|
-          if value
-            super_merge(value, asd, old_json_schema[key])
-          else
-            old_json_schema[key].merge!(asd)
-          end
+      def combi
+        inception(@json_schema, @combinations).each do |combination|
+          combination[0] = @json_schema.merge(combination[0])
+          combination[1] = ['enum', combination[1]]
         end
-        old_json_schema
       end
 
-      def clone_hash(old_json_schema)
-        new_json_schema = {}
-        old_json_schema.each do |key, value|
-          if value.is_a?(Hash)
-            new_json_schema.merge!(key => clone_hash(value))
-          elsif value
-            new_json_schema.merge!(key => value.clone)
-          else
-            new_json_schema.merge!(key => nil)
+      def inception(json_schema, combinations)
+        json_schema.each do |key, value|
+          if key == 'enum' && value.size > 1
+            schema = json_schema.dup
+            one_of = schema.delete('enum')
+            one_of.each_index do |index|
+              combinations.push([schema.merge('enum' => [one_of[index]]), "enum.#{one_of[index]}"])
+            end
+          elsif value.is_a?(Hash)
+            com = inception(value, [])
+            com.each do |combination|
+              combination[0] = { key => value.merge(combination[0])}
+              combination[1] = "#{key}.#{combination[1]}"
+            end
+            combinations += com
           end
         end
-        new_json_schema
-      end
-
-      def new_enum(json_schema)
-        res = []
-        new_keys(json_schema).map do |new_key|
-          new_json_shema = json_schema.dup
-          new_json_shema['enum'] = [new_key]
-          res.push([new_json_shema, ['enum', new_key]])
-        end
-        res
-      end
 
-      def new_keys(json_schema)
-        return [] unless json_schema['enum']
-        json_schema['enum']
+        combinations
       end
     end
   end

data/lib/fitting/cover/json_schema_one_of.rb

@@ -16,16 +16,18 @@ module Fitting
       def inception(json_schema, combinations)
         json_schema.each do |key, value|
           if key == 'oneOf'
-            one_of = json_schema.delete('oneOf')
+            schema = json_schema.dup
+            one_of = schema.delete('oneOf')
             one_of.each_index do |index|
-              combinations.push([json_schema.merge('oneOf' => [one_of[index]]), "oneOf.#{index}"])
+              combinations.push([schema.merge('oneOf' => [one_of[index]]), "oneOf.#{index}"])
             end
           elsif value.is_a?(Hash)
-            inception(value, combinations)
-            combinations.each do |combination|
-              combination[0] = { key => combination[0]}
+            com = inception(value, [])
+            com.each do |combination|
+              combination[0] = { key => value.merge(combination[0])}
               combination[1] = "#{key}.#{combination[1]}"
             end
+            combinations += com
           end
         end
 

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,55 @@
+require 'fitting/report/action'
+
+module Fitting
+  module Report
+    class Actions
+      def initialize(prefix, tomogram_json_path)
+        actions = Tomograph::Tomogram.new(
+            prefix: prefix,
+            tomogram_json_path: tomogram_json_path
+        )
+        @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