fitting 2.12.0 → 2.14.1

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" * ((3 - action[:path].size / 8) + 3)
+            @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,53 @@
+require 'fitting/report/actions'
+
+module Fitting
+  module Report
+    class Prefix
+      def initialize(name, tomogram_json_path, skip = false)
+        @name = name
+        @tomogram_json_path = tomogram_json_path
+        @tests = Fitting::Report::Tests.new([])
+        @skip = skip
+        unless skip
+          @actions = Fitting::Report::Actions.new(name, tomogram_json_path)
+        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,44 @@
+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(prefix['name'], prefix['tomogram_json_path'], prefix['skip']))
+        end
+      end
+
+      def is_there_a_suitable_prefix?(test_path)
+        @prefixes.map do |prefix|
+          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 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']
+      end
+
+      def 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

data/lib/fitting/report/responses.rb

@@ -0,0 +1,48 @@
+require 'fitting/report/response'
+
+module Fitting
+  module Report
+    class Responses
+      def initialize(responses)
+        @responses = responses
+        @responses = []
+        responses.to_a.map do |response|
+          @responses.push(Fitting::Report::Response.new(response))
+        end
+      end
+
+      def to_a
+        @responses
+      end
+
+      def join(tests)
+        tests.to_a.map do |test|
+          if is_there_a_suitable_response?(test)
+            cram_into_the_appropriate_response(test)
+            test.mark_response
+          end
+        end
+      end
+
+      def is_there_a_suitable_response?(test)
+        return false if @responses.nil?
+        @responses.map do |response|
+          return true if response.status.to_s == test.status &&
+              JSON::Validator.fully_validate(response.body, test.body) == []
+        end
+
+        false
+      end
+
+      def cram_into_the_appropriate_response(test)
+        @responses.map do |response|
+          if response.status.to_s == test.status &&
+              JSON::Validator.fully_validate(response.body, test.body) == []
+            response.add_test(test)
+            return
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fitting/report/test.rb

@@ -0,0 +1,61 @@
+module Fitting
+  module Report
+    class Test
+      def initialize(test)
+        @test = test
+        @prefix = false
+        @action = false
+        @response = false
+        @combination = false
+      end
+
+      def path
+        @test['path']
+      end
+
+      def method
+        @test['method']
+      end
+
+      def status
+        @test['response']['status'].to_s
+      end
+
+      def body
+        @test['response']['body']
+      end
+
+      def mark_prefix
+        @prefix = true
+      end
+
+      def mark_action
+        @action = true
+      end
+
+      def mark_response
+        @response = true
+      end
+
+      def mark_combination
+        @combination = true
+      end
+
+      def is_there_a_prefix?
+        @prefix
+      end
+
+      def is_there_an_actions?
+        @action
+      end
+
+      def is_there_an_responses?
+        @response
+      end
+
+      def is_there_an_combinations?
+        @combination
+      end
+    end
+  end
+end

data/lib/fitting/report/tests.rb

@@ -0,0 +1,62 @@
+require 'fitting/report/test'
+
+module Fitting
+  module Report
+    class Tests
+      def initialize(tests)
+        @tests = tests
+      end
+
+      def self.new_from_config(tests_path)
+        tests = []
+        Dir[tests_path].each do |file|
+          JSON.load(File.read(file)).map do |test|
+            tests.push(Fitting::Report::Test.new(test))
+          end
+        end
+        tests.sort { |a, b| b.path <=> a.path }
+        new(tests)
+      end
+
+      def without_prefixes
+        @tests.inject([]) do |result, test|
+          result.push(test.path) unless test.is_there_a_prefix?
+          result
+        end
+      end
+
+      def without_actions
+        @tests.inject([]) do |result, test|
+          result.push("#{test.method} #{test.path}") unless test.is_there_an_actions?
+          result
+        end
+      end
+
+      def without_responses
+        @tests.inject([]) do |result, test|
+          result.push("#{test.method} #{test.path}") unless test.is_there_an_responses?
+          result
+        end
+      end
+
+      def without_combinations
+        @tests.inject([]) do |result, test|
+          result.push(test.path) unless test.is_there_an_combinations?
+          result
+        end
+      end
+
+      def push(test)
+        @tests.push(test)
+      end
+
+      def size
+        @tests.size
+      end
+
+      def to_a
+        @tests
+      end
+    end
+  end
+end

data/lib/fitting/tests.rb

@@ -9,7 +9,6 @@ module Fitting
     def save
       make_dir('fitting_tests')
       array = @tested_requests.inject([]) do |res, request|
-        next res unless request.path.to_s.start_with?(Fitting.configuration.prefix)
         res.push(request.to_spherical.to_hash)
       end
       json = JSON.dump(array)

data/lib/fitting/version.rb

@@ -1,3 +1,3 @@
 module Fitting
-  VERSION = '2.12.0'.freeze
+  VERSION = '2.14.1'.freeze
 end