fitting 2.18.0 → 3.0.0

data/lib/fitting/report/tests.rb

@@ -3,13 +3,26 @@ require 'fitting/report/test'
 module Fitting
   module Report
     class Tests
+      attr_reader :tests
+
       def initialize(tests)
         @tests = tests
       end
 
-      def self.new_from_config(tests_path)
+      def self.new_from_config
+        tests = []
+        Dir["#{Fitting.configuration.rspec_json_path}/*.json"].each do |file|
+          JSON.parse(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 self.new_from_outgoing_config
         tests = []
-        Dir[tests_path].each do |file|
+        Dir["#{Fitting.configuration.webmock_json_path}/*.json"].each do |file|
           JSON.parse(File.read(file)).map do |test|
             tests.push(Fitting::Report::Test.new(test))
           end
@@ -19,45 +32,45 @@ module Fitting
       end
 
       def without_prefixes
-        @tests.each_with_object([]) do |test, result|
+        tests.each_with_object([]) do |test, result|
           result.push(test.path) unless test.there_a_prefix?
         end
       end
 
       def without_actions
-        @tests.each_with_object([]) do |test, result|
+        tests.each_with_object([]) do |test, result|
           result.push("#{test.method} #{test.path}") unless test.there_an_actions?
         end
       end
 
       def without_responses
-        @tests.each_with_object([]) do |test, result|
+        tests.each_with_object([]) do |test, result|
           result.push(test.id) unless test.there_an_responses?
         end
       end
 
       def without_combinations
-        @tests.each_with_object([]) do |test, result|
+        tests.each_with_object([]) do |test, result|
           result.push(test.path) unless test.there_an_combinations?
         end
       end
 
       def push(test)
-        @tests.push(test)
+        tests.push(test)
       end
 
       def size
-        @tests.size
+        tests.size
       end
 
       def to_a
-        @tests
+        tests
       end
 
       def to_h
         return @hash if @hash
 
-        @hash = @tests.inject({}) do |res, test|
+        @hash = tests.inject({}) do |res, test|
           res.merge!(test.id => test.to_h)
         end
       end

data/lib/fitting/storage/responses.rb

@@ -1,24 +1,20 @@
-require 'fitting/statistics'
-require 'fitting/tests'
 require 'fitting/records/tested/request'
 
 module Fitting
   module Storage
     class Responses
+      attr_reader :tested_requests
+
       def initialize
         @tested_requests = []
       end
 
-      def add(env_response, test_title = '')
-        @tested_requests.push(Fitting::Records::Tested::Request.new(env_response, test_title))
-      end
-
-      def statistics
-        Fitting::Statistics.new(@tested_requests)
+      def add(response, example)
+        tested_requests.push(Fitting::Records::Tested::Request.new(response, example))
       end
 
       def tests
-        Fitting::Tests.new(@tested_requests)
+        Fitting::Tests.new(tested_requests)
       end
     end
   end

data/lib/fitting/tests.rb

@@ -1,5 +1,3 @@
-require 'fitting/statistics/template'
-
 module Fitting
   class Tests
     def initialize(tested_requests)
@@ -7,13 +5,23 @@ module Fitting
     end
 
     def save
-      make_dir('fitting_tests')
+      make_dir(Fitting.configuration.rspec_json_path)
+      array = @tested_requests.inject([]) do |res, request|
+        res.push(request.to_spherical.to_hash)
+      end
+      json = JSON.dump(array)
+
+      File.open("#{Fitting.configuration.rspec_json_path}/test#{ENV['TEST_ENV_NUMBER']}.json", 'w') { |file| file.write(json) }
+    end
+
+    def outgoing_save
+      make_dir('./outgoing_request_tests')
       array = @tested_requests.inject([]) do |res, request|
         res.push(request.to_spherical.to_hash)
       end
       json = JSON.dump(array)
 
-      File.open("fitting_tests/test#{ENV['TEST_ENV_NUMBER']}.json", 'w') { |file| file.write(json) }
+      File.open("./outgoing_request_tests/test#{ENV['TEST_ENV_NUMBER']}.json", 'w') { |file| file.write(json) }
     end
 
     def make_dir(dir_name)

data/lib/fitting/version.rb

@@ -1,3 +1,3 @@
 module Fitting
-  VERSION = '2.18.0'.freeze
+  VERSION = '3.0.0'.freeze
 end

data/lib/fitting.rb

@@ -1,73 +1,68 @@
 require 'fitting/version'
 require 'fitting/configuration'
-require 'fitting/matchers/response_matcher'
-require 'fitting/documentation'
+
 require 'fitting/storage/responses'
+require 'fitting/tests'
+require 'fitting/cover/json_schema_enum'
+require 'fitting/cover/json_schema_one_of'
+require 'fitting/records/documented/request'
 require 'fitting/railtie' if defined?(Rails)
 
 module Fitting
   class << self
+    def configuration
+      yaml = YAML.safe_load(File.read('.fitting.yml'))
+      @configuration ||= Configuration.new(yaml)
+    end
+
     def configure
-      yield configuration
+      yield(configuration)
     end
 
-    def configuration
-      @configuration ||= Configuration.craft
+    def clear_tests_directory
+      FileUtils.rm_r Dir.glob(configuration.rspec_json_path), force: true
+      FileUtils.rm_r Dir.glob(configuration.webmock_json_path), force: true
     end
 
-    def statistics
+    def save_test_data
+      clear_tests_directory
+
+      outgoing_responses = Fitting::Storage::Responses.new
       responses = Fitting::Storage::Responses.new
 
       RSpec.configure do |config|
-        config.after(:each, type: :controller) do
-          responses.add(response, inspect)
+        if defined?(WebMock)
+          config.before(:each) do |example|
+            WebMock.after_request do |request_signature, response|
+              env = Rack::MockRequest.env_for(request_signature.uri, { method: request_signature.method })
+              # Парсим в тот формат с которым работает fitting
+              mock_request = ActionDispatch::Request.new(env)
+              mock_response = ActionDispatch::Response.create(response.status.first || 200, response.headers || {},
+                                                              response.body || {})
+              mock_response.instance_variable_set(:@request, mock_request)
+
+              outgoing_responses.add(mock_response, example)
+            end
+          end
         end
 
-        config.after(:suite) do
-          responses.statistics.save
+        config.after(:each, type: :request) do |example|
+          responses.add(response, example)
         end
-      end
-    end
 
-    extend Gem::Deprecate
-    deprecate :statistics, :save_test_data, 2022, 1
-
-    def save_test_data
-      responses = Fitting::Storage::Responses.new
-
-      FileUtils.rm_r Dir.glob('fitting_tests/*'), force: true
-
-      RSpec.configure do |config|
-        config.after(:each, type: :request) do
-          responses.add(response, inspect)
+        config.after(:each, type: :controller) do |example|
+          responses.add(response, example)
         end
 
-        config.after(:each, type: :controller) do
-          responses.add(response, inspect)
+        config.after(:each) do
+          WebMock::CallbackRegistry.reset
         end
 
         config.after(:suite) do
           responses.tests.save
+          outgoing_responses.tests.outgoing_save
         end
       end
     end
   end
-
-  def self.loaded_tasks=(val)
-    @loaded_tasks = val
-  end
-
-  def self.loaded_tasks
-    @loaded_tasks
-  end
-
-  def self.load_tasks
-    return if loaded_tasks
-
-    self.loaded_tasks = true
-
-    Dir[File.join(File.dirname(__FILE__), 'tasks', '**/*.rake')].each do |rake|
-      load rake
-    end
-  end
 end

data/lib/tasks/fitting.rake

@@ -1,10 +1,4 @@
 require 'fitting/records/spherical/requests'
-require 'fitting/configuration'
-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'
@@ -12,8 +6,8 @@ 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')
+    tests = Fitting::Report::Tests.new_from_config
+    prefixes = Fitting::Report::Prefixes.new(Fitting.configuration.prefixes)
 
     prefixes.join(tests)
 
@@ -88,187 +82,10 @@ namespace :fitting do
     )
 
     puts console.output
+    puts console.output_sum
 
     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
-        next unless 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
-
-    actions.map do |action|
-      action.to_hash['responses'].map do |response|
-        response['tests'] ||= []
-        response['tests'].map do |test|
-          next unless response['combination'][0]
-
-          response['combination'].map do |combination|
-            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 => e
-            combination['error'].push({ test: test, error: e })
-          end
-        end
-      end
-    end
-
-    actions_test = { actions: actions, tests: tests }
-
-    makedirs('fitting')
-    File.open('fitting/old_report.json', 'w') { |file| file.write(JSON.dump(actions_test)) }
-  end
-
-  # deprecated
-  desc 'Fitting documentation'
-  task :documentation do
-    documented_unit = Fitting::Statistics::Template.new(
-      Fitting::Records::Spherical::Requests.new,
-      Fitting.configuration
-    )
-    puts documented_unit.stats
-
-    unless documented_unit.not_covered == "\n"
-      puts 'Not all responses from the whitelist are covered!'
-      exit 1
-    end
-  end
-
-  desc 'Fitting documentation responses cover'
-  task :documentation_responses, [:size] => :environment do |_, args|
-    case args.size
-    when 'xs'
-      documented_unit = Fitting::Statistics::Template.new(
-        Fitting::Records::Spherical::Requests.new,
-        Fitting.configuration
-      )
-      puts documented_unit.stats
-
-      unless documented_unit.not_covered == "\n"
-        puts 'Not all responses from the whitelist are covered!'
-        exit 1
-      end
-    when 's'
-      documented_unit = Fitting::Statistics::Template.new(
-        Fitting::Records::Spherical::Requests.new,
-        Fitting.configuration,
-        'cover'
-      )
-      puts documented_unit.stats
-
-      unless documented_unit.not_covered == "\n"
-        puts 'Not all responses from the whitelist are covered!'
-        exit 1
-      end
-    when 'm'
-      documented_unit = Fitting::Statistics::Template.new(
-        Fitting::Records::Spherical::Requests.new,
-        Fitting.configuration,
-        'cover_enum'
-      )
-      puts documented_unit.stats
-
-      unless documented_unit.not_covered == "\n"
-        puts 'Not all responses from the whitelist are covered!'
-        exit 1
-      end
-    when '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, m or l'
-    end
-  end
-
-  desc 'Fitting documentation responses cover error'
-  task :documentation_responses_error, [:size] => :environment do |_, args|
-    case args.size
-    when 's'
-      documented_unit = Fitting::Statistics::TemplateCoverError.new(
-        Fitting::Records::Spherical::Requests.new,
-        Fitting.configuration
-      )
-      puts documented_unit.stats
-    when 'm'
-      documented_unit = Fitting::Statistics::TemplateCoverErrorEnum.new(
-        Fitting::Records::Spherical::Requests.new,
-        Fitting.configuration
-      )
-      puts documented_unit.stats
-    when 'l'
-      documented_unit = Fitting::Statistics::TemplateCoverErrorOneOf.new(
-        Fitting::Records::Spherical::Requests.new,
-        Fitting.configuration
-      )
-      puts documented_unit.stats
-    else
-      puts 'need key s, m or l'
-    end
-  end
-
-  # deprecated
-  desc 'Fitting tests'
-  task :tests do
-    realized_unit = Fitting::Records::RealizedUnit.new(
-      Fitting::Records::Spherical::Requests.new,
-      Fitting.configuration.tomogram
-    )
-    puts Fitting::Templates::RealizedTemplate.new(realized_unit).to_s
-
-    unless realized_unit.fully_covered?
-      puts 'Not all responses from the whitelist are covered!'
-      exit 1
-    end
-  end
-
-  desc 'Fitting tests'
-  task :tests_responses, [:size] => :environment do |_, args|
-    if args.size == 'xs'
-      realized_unit = Fitting::Records::RealizedUnit.new(
-        Fitting::Records::Spherical::Requests.new,
-        Fitting.configuration.tomogram
-      )
-      puts Fitting::Templates::RealizedTemplate.new(realized_unit).to_s
-
-      unless realized_unit.fully_covered?
-        puts 'Not all responses from the whitelist are covered!'
-        exit 1
-      end
-    else
-      puts 'need key xs'
-    end
   end
 end

data/lib/tasks/fitting_outgoing.rake

@@ -0,0 +1,91 @@
+require 'fitting/records/spherical/requests'
+require 'fitting/cover/json_schema'
+require 'fitting/report/prefixes'
+require 'fitting/report/tests'
+require 'fitting/report/console'
+
+namespace :fitting_out do
+  task :report do
+    tests = Fitting::Report::Tests.new_from_outgoing_config
+    prefixes = Fitting::Report::Prefixes.new(Fitting.configuration.prefixes)
+
+    prefixes.join(tests)
+
+    prefixes.to_a.map do |prefix|
+      prefix.actions.join(prefix.tests) unless prefix.skip?
+    end
+
+    prefixes.to_a.map do |prefix|
+      next if prefix.skip?
+
+      prefix.actions.to_a.map do |action|
+        action.responses.join(action.tests)
+      end
+    end
+
+    prefixes.to_a.map do |prefix|
+      next if prefix.skip?
+
+      prefix.actions.to_a.map do |action|
+        action.responses.to_a.map do |response|
+          response.combinations.join(response.tests)
+        end
+      end
+    end
+
+    report = JSON.pretty_generate(
+      {
+        tests_without_prefixes: tests.without_prefixes,
+        prefixes_details: prefixes.to_a.map(&: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|
+      next if prefix.skip?
+
+      prefix.actions.to_a.map do |action|
+        action.responses.to_a.map do |response|
+          json_schemas[response.id] = response.body
+          response.combinations.to_a.map do |combination|
+            combinations.merge!(combination.id => combination.json_schema)
+          end
+        end
+      end
+    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..] == '.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(&:details)
+    )
+
+    puts console.output
+    puts console.output_sum
+
+    exit 1 unless console.good?
+
+    exit 0
+  end
+end