fitting 2.11.0 → 2.14.0

data/lib/fitting/statistics/cover_error_one_of.rb

@@ -0,0 +1,27 @@
+module Fitting
+  class Statistics
+    class CoverErrorOneOf
+      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_one_of.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/list.rb

@@ -45,6 +45,8 @@ module Fitting
           res.push("#{json_schema.cover}% #{response.status}")
         elsif @depth == 'cover_enum'
           res.push("#{json_schema.cover_enum}% #{response.status}")
+        elsif @depth == 'cover_one_of'
+          res.push("#{json_schema.cover_one_of}% #{response.status}")
         end
       end
     end

data/lib/fitting/statistics/measurement_cover_one_of.rb

@@ -0,0 +1,92 @@
+module Fitting
+  class Statistics
+    class MeasurementCoverOneOf
+      attr_reader :requests, :all_responses, :cover_responses, :not_cover_responses, :max_response_path,
+                  :coverage_fully, :coverage_non, :coverage_partially, :not_covered_responses
+
+      def initialize(requests)
+        @requests = requests
+        @all_responses = 0
+        @cover_responses = 0
+        @not_cover_responses = 0
+        @max_response_path = 0
+        @coverage_fully = []
+        @coverage_non = []
+        @coverage_partially = []
+        @not_covered_responses = []
+        check_responses
+      end
+
+      def check_responses
+        return if @ready
+
+        @requests.map do |request|
+          chech_request(request)
+        end
+
+        @ready = true
+      end
+
+      private
+
+      def chech_request(request)
+        check_cover(request)
+        coverage_push(request)
+
+        @max_response_path = request.path.to_s.size / 8 if request.path.to_s.size / 8 > @max_response_path
+        request.responses.map do |response|
+          check_response(response, request)
+        end
+      end
+
+      def check_response(response, request)
+        json_schema_index = 0
+        response.json_schemas.map do |json_schema|
+          json_schema_index = check_json_schema(json_schema, request, response, json_schema_index)
+        end
+      end
+
+      def check_json_schema(json_schema, request, response, json_schema_index)
+        if json_schema.cover_one_of != 100
+          @not_cover_responses += 1
+          @not_covered_responses.push("#{request.method}\t#{request.path} #{response.status} #{json_schema_index}")
+        else
+          @cover_responses += 1
+        end
+        @all_responses += 1
+        json_schema_index + 1
+      end
+
+      def coverage_push(request)
+        if @all == @cover
+          @coverage_fully.push(request)
+        elsif @all == @not_cover
+          @coverage_non.push(request)
+        else
+          @coverage_partially.push(request)
+        end
+      end
+
+      def check_cover(request)
+        @all = 0
+        @cover = 0
+        @not_cover = 0
+
+        request.responses.map do |response|
+          response.json_schemas.map do |json_schema|
+            count_cover(json_schema)
+          end
+        end
+      end
+
+      def count_cover(json_schema)
+        @all += 1
+        if json_schema.cover_one_of != 100
+          @not_cover += 1
+        else
+          @cover += 1
+        end
+      end
+    end
+  end
+end

data/lib/fitting/statistics/template.rb

@@ -3,6 +3,7 @@ require 'fitting/statistics/analysis'
 require 'fitting/statistics/measurement'
 require 'fitting/statistics/measurement_cover'
 require 'fitting/statistics/measurement_cover_enum'
+require 'fitting/statistics/measurement_cover_one_of'
 require 'fitting/records/unit/request'
 require 'fitting/storage/white_list'
 require 'fitting/records/documented/request'
@@ -53,6 +54,8 @@ module Fitting
             Fitting::Statistics::MeasurementCover.new(white_unit)
           elsif @depth == 'cover_enum'
             Fitting::Statistics::MeasurementCoverEnum.new(white_unit)
+          elsif @depth == 'cover_one_of'
+            Fitting::Statistics::MeasurementCoverOneOf.new(white_unit)
           end
       end
 
@@ -64,6 +67,8 @@ module Fitting
             Fitting::Statistics::MeasurementCover.new(black_unit)
           elsif @depth == 'cover_enum'
             Fitting::Statistics::MeasurementCoverEnum.new(black_unit)
+          elsif @depth == 'cover_one_of'
+            Fitting::Statistics::MeasurementCoverOneOf.new(black_unit)
           end
       end
 

data/lib/fitting/statistics/template_cover_error_one_of.rb

@@ -0,0 +1,50 @@
+require 'fitting/statistics/cover_error_one_of'
+require 'fitting/records/unit/request'
+require 'fitting/storage/white_list'
+require 'fitting/records/documented/request'
+
+module Fitting
+  class Statistics
+    class TemplateCoverErrorOneOf
+      def initialize(tested_requests, config)
+        @tested_requests = tested_requests
+        @config = config
+      end
+
+      def stats
+        "#{white_statistics}\n\n"
+      end
+
+      def white_statistics
+        @white_statistics ||= Fitting::Statistics::CoverErrorOneOf.new(white_unit)
+      end
+
+      def white_unit
+        @white_unit_requests ||= documented_requests_white.inject([]) do |res, documented_request|
+          res.push(Fitting::Records::Unit::Request.new(documented_request, @tested_requests))
+        end
+      end
+
+      def documented_requests_white
+        @documented_requests_white ||= documented.find_all(&:white)
+      end
+
+      def documented
+        @documented_requests ||= @config.tomogram.to_a.inject([]) do |res, tomogram_request|
+          res.push(Fitting::Records::Documented::Request.new(tomogram_request, white_list.to_a))
+        end
+      end
+
+      def white_list
+        @white_list ||= Fitting::Storage::WhiteList.new(
+          @config.prefix,
+          @config.white_list,
+          @config.resource_white_list,
+          @config.include_resources,
+          @config.include_actions,
+          @config.tomogram.to_resources
+        )
+      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.11.0'.freeze
+  VERSION = '2.14.0'.freeze
 end

data/lib/tasks/fitting.rake

@@ -4,8 +4,137 @@ require 'fitting/records/realized_unit'
 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.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)) }
+
+    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))
+    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
     documented_unit = Fitting::Statistics::Template.new(
@@ -53,12 +182,24 @@ namespace :fitting do
       )
       puts documented_unit.stats
 
+      unless documented_unit.not_covered == "\n"
+        puts 'Not all responses from the whitelist are covered!'
+        exit 1
+      end
+    elsif args.size == 'l'
+      documented_unit = Fitting::Statistics::Template.new(
+        Fitting::Records::Spherical::Requests.new,
+        Fitting.configuration,
+        'cover_one_of'
+      )
+      puts documented_unit.stats
+
       unless documented_unit.not_covered == "\n"
         puts 'Not all responses from the whitelist are covered!'
         exit 1
       end
     else
-      puts 'need key xs, s or m'
+      puts 'need key xs, s, m or l'
     end
   end
 
@@ -76,11 +217,18 @@ namespace :fitting do
         Fitting.configuration
       )
       puts documented_unit.stats
+    elsif args.size == 'l'
+      documented_unit = Fitting::Statistics::TemplateCoverErrorOneOf.new(
+        Fitting::Records::Spherical::Requests.new,
+        Fitting.configuration
+      )
+      puts documented_unit.stats
     else
-      puts 'need key s or m'
+      puts 'need key s, m or l'
     end
   end
 
+  # deprecated
   desc 'Fitting tests'
   task :tests do
     realized_unit = Fitting::Records::RealizedUnit.new(

data/lib/templates/bomboniere/.gitignore

@@ -0,0 +1,21 @@
+.DS_Store
+node_modules
+
+# local env files
+.env.local
+.env.*.local
+
+# Log files
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

data/lib/templates/bomboniere/.tool-versions

@@ -0,0 +1 @@
+nodejs 13.1.0

data/lib/templates/bomboniere/README.md

@@ -0,0 +1,19 @@
+# bomboniere
+
+## Project setup
+```
+npm install
+```
+
+### Compiles and hot-reloads for development
+```
+npm run serve
+```
+
+### Compiles and minifies for production
+```
+npm run build
+```
+
+### Customize configuration
+See [Configuration Reference](https://cli.vuejs.org/config/).