fitting 2.12.1 → 2.15.0

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,75 @@
+module Fitting
+  module Report
+    class Test
+      def initialize(test)
+        @test = test
+        @prefix = false
+        @action = false
+        @response = false
+        @combination = false
+        @id = SecureRandom.hex
+      end
+
+      def id
+        @id
+      end
+
+      def to_h
+        {
+            path: path,
+            method: method,
+            status: status,
+            body: body
+        }
+      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,69 @@
+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.id) 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
+
+      def to_h
+        return @hash if @hash
+        @hash = @tests.inject({}) do |res, test|
+          res.merge!(test.id => test.to_h)
+        end
+      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.1'.freeze
+  VERSION = '2.15.0'.freeze
 end

data/lib/tasks/fitting.rake

@@ -5,8 +5,138 @@ require 'fitting/templates/realized_template'
 require 'fitting/statistics/template_cover_error'
 require 'fitting/statistics/template_cover_error_enum'
 require 'fitting/statistics/template_cover_error_one_of'
+require 'fitting/cover/json_schema'
+require 'fitting/report/prefixes'
+require 'fitting/report/tests'
+require 'fitting/report/console'
 
 namespace :fitting do
+  task :report do
+    tests = Fitting::Report::Tests.new_from_config('fitting_tests/*.json')
+    prefixes = Fitting::Report::Prefixes.new('.fitting.yml')
+
+    prefixes.join(tests)
+
+    prefixes.to_a.map do |prefix|
+      prefix.actions.join(prefix.tests) unless prefix.skip?
+    end
+
+    prefixes.to_a.map do |prefix|
+      prefix.actions.to_a.map do |action|
+        action.responses.join(action.tests)
+      end unless prefix.skip?
+    end
+
+    prefixes.to_a.map do |prefix|
+      prefix.actions.to_a.map do |action|
+        action.responses.to_a.map do |response|
+          response.combinations.join(response.tests)
+        end
+      end unless prefix.skip?
+    end
+
+    report = JSON.pretty_generate(
+        {
+            tests_without_prefixes: tests.without_prefixes,
+            prefixes_details: prefixes.to_a.map { |p| p.details }
+        }
+    )
+
+    destination = 'fitting'
+    FileUtils.mkdir_p(destination)
+    FileUtils.rm_r Dir.glob("#{destination}/*"), :force => true
+    File.open('fitting/report.json', 'w') { |file| file.write(report) }
+
+    gem_path = $LOAD_PATH.find { |i| i.include?('fitting') }
+    source_path = "#{gem_path}/templates/bomboniere/dist"
+    FileUtils.copy_entry source_path, destination
+
+    json_schemas = {}
+    combinations = {}
+    prefixes.to_a.map do |prefix|
+      prefix.actions.to_a.map do |action|
+        action.responses.to_a.map do |response|
+          json_schemas.merge!(response.id => response.body)
+          response.combinations.to_a.map do |combination|
+            combinations.merge!(combination.id => combination.json_schema)
+          end
+        end
+      end unless prefix.skip?
+    end
+    File.open('fitting/json_schemas.json', 'w') { |file| file.write(JSON.pretty_generate(json_schemas)) }
+    File.open('fitting/combinations.json', 'w') { |file| file.write(JSON.pretty_generate(combinations)) }
+    File.open('fitting/tests.json', 'w') { |file| file.write(JSON.pretty_generate(tests.to_h)) }
+
+    js_path =  Dir["#{destination}/js/*"].find { |f| f[0..14] == 'fitting/js/app.' and f[-3..-1] == '.js' }
+    js_file =  File.read(js_path)
+    new_js_file = js_file.gsub("{stub:\"prefixes report\"}", report)
+    new_js_file = new_js_file.gsub("{stub:\"for action page\"}", report)
+    new_js_file = new_js_file.gsub("{stub:\"json-schemas\"}", JSON.pretty_generate(json_schemas))
+    new_js_file = new_js_file.gsub("{stub:\"combinations\"}", JSON.pretty_generate(combinations))
+    new_js_file = new_js_file.gsub("{stub:\"tests\"}", JSON.pretty_generate(tests.to_h))
+    File.open(js_path, 'w') { |file| file.write(new_js_file) }
+
+    console = Fitting::Report::Console.new(
+        tests.without_prefixes,
+        prefixes.to_a.map { |p| p.details }
+    )
+
+    puts console.output
+
+    exit 1 unless console.good?
+
+    exit 0
+
+    actions.map do |action|
+      action.to_hash["responses"].map do |response|
+        response['combination'] ||= []
+        combinations = Fitting::Cover::JSONSchema.new(response['body']).combi + Fitting::Cover::JSONSchemaEnum.new(response['body']).combi + Fitting::Cover::JSONSchemaOneOf.new(response['body']).combi
+        if combinations != []
+          combinations.map do |combination|
+            response['combination'].push(
+                {
+                    'json_schema' => combination[0],
+                    'type' => combination[1][0],
+                    'combination' => combination[1][1],
+                    'tests' => [],
+                    'error' => []
+                }
+            )
+          end
+        end
+      end
+    end
+
+    actions.map do |action|
+      action.to_hash["responses"].map do |response|
+        response['tests'] ||= []
+        response['tests'].map do |test|
+          if response['combination'][0]
+            response['combination'].map do |combination|
+              begin
+                res = JSON::Validator.fully_validate(combination['json_schema'], test['response']['body'])
+                if res == []
+                  combination['tests'].push(test)
+                  response['tests'] = response['tests'] - [test]
+                  next
+                else
+                  combination['error'].push({test: test, error: res})
+                end
+              rescue JSON::Schema::SchemaError => error
+                combination['error'].push({test: test, error: error})
+              end
+            end
+          end
+        end
+      end
+    end
+
+    actions_test = {actions: actions, tests: tests}
+
+    makedirs('fitting')
+    File.open('fitting/old_report.json', 'w') { |file| file.write(MultiJson.dump(actions_test)) }
+  end
+
   # deprecated
   desc 'Fitting documentation'
   task :documentation do