fitting 3.0.2 → 4.0.1

data/lib/fitting/report/responses.rb

@@ -3,6 +3,15 @@ require 'fitting/report/response'
 module Fitting
   module Report
     class Responses
+      class NotFound < RuntimeError
+        attr_reader :log
+
+        def initialize(msg, log)
+          @log = log
+          super(msg)
+        end
+      end
+
       def initialize(responses)
         @responses = responses
         @responses = []
@@ -11,38 +20,25 @@ module Fitting
         end
       end
 
-      def to_a
-        @responses
-      end
-
-      def join(tests)
-        tests.to_a.map do |test|
-          if there_a_suitable_response?(test)
-            cram_into_the_appropriate_response(test)
-            test.mark_response
-          end
-        end
-      end
-
-      def there_a_suitable_response?(test)
-        return false if @responses.nil?
-
+      def find!(log)
+        message = ""
         @responses.map do |response|
-          return true if response.status.to_s == test.status &&
-                         JSON::Validator.fully_validate(response.body, test.body) == []
+          if response.status.to_s == log.status
+            if JSON::Validator.fully_validate(response.body, log.body) == []
+              return response
+            else
+              message += "\nbody: #{response.body}\nvalidate: #{JSON::Validator.fully_validate(response.body, log.body)}\n"
+            end
+          else
+            message += "\nstatus: #{response.status}\n"
+          end
         end
 
-        false
+        raise NotFound.new("method: #{log.method}, host: #{log.host}, path: #{log.path}, status: #{log.status}, body: #{log.body}\n\n#{message}", log)
       end
 
-      def cram_into_the_appropriate_response(test)
-        @responses.map do |response|
-          next unless response.status.to_s == test.status &&
-                      JSON::Validator.fully_validate(response.body, test.body) == []
-
-          response.add_test(test)
-          break
-        end
+      def to_a
+        @responses
       end
     end
   end

data/lib/fitting/report/tests.rb

@@ -11,10 +11,8 @@ module Fitting
 
       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
+        File.read('log/test.log').split("\n").select{|f|f.include?('incoming request ')}.each do |test|
+          tests.push(Fitting::Report::Test.new(JSON.load(test.split('incoming request ')[1])))
         end
         tests.sort { |a, b| b.path <=> a.path }
         new(tests)
@@ -22,10 +20,8 @@ module Fitting
 
       def self.new_from_outgoing_config
         tests = []
-        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
+        File.read('log/test.log').split("\n").select{|f|f.include?('outgoing request ')}.each do |test|
+          tests.push(Fitting::Report::Test.new(JSON.load(test.split('outgoing request ')[1])))
         end
         tests.sort { |a, b| b.path <=> a.path }
         new(tests)

data/lib/fitting/skip/action.rb

@@ -0,0 +1,44 @@
+module Fitting
+  class Skip
+    class Action
+      attr_accessor :host, :method, :path, :code
+
+      def initialize(host, method, path, code)
+        @host = host
+        @method = method
+        @path = path
+        @code = code
+      end
+
+      def self.all(actions)
+        return [] unless actions
+        actions.map do |action|
+          next if action['method'].nil? || action['path'].nil?
+          new(action['host'], action['method'], action['path'], action['code'])
+        end.compact
+      end
+
+      def self.find(actions, log)
+        actions.find do |action|
+          if action.host == log.host &&
+            action.method == log.method &&
+            action.path_match(log.path)
+            return action if action.code == nil
+            return action if action.code.to_s == log.status
+          end
+        end
+      end
+
+      def path_match(find_path)
+        regexp =~ find_path
+      end
+
+      def regexp
+        str = Regexp.escape(path)
+        str = str.gsub(/\\{\w+\\}/, '[^&=\/]+')
+        str = "\\A#{str}\\z"
+        Regexp.new(str)
+      end
+    end
+  end
+end

data/lib/fitting/skip/api.rb

@@ -0,0 +1,29 @@
+module Fitting
+  class Skip
+    class API
+      attr_accessor :type, :host, :prefix, :path
+
+      def initialize(type, host, prefix)
+        @type = type
+        @host = host
+        @prefix = prefix
+      end
+
+      def self.all(apis)
+        return [] unless apis
+        apis.map do |api|
+          next if api['method'] || api['path']
+          new('provided', api['host'], api['prefix'])
+        end.compact
+      end
+
+      def self.find(apis, log)
+        apis.find do |api|
+          if log.host == api.host
+            api.prefix.nil? || api.prefix == '' || log.path[0..api.prefix.size - 1] == api.prefix
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fitting/skip.rb

@@ -0,0 +1,21 @@
+require 'fitting/skip/api'
+require 'fitting/skip/action'
+
+module Fitting
+  class Skip
+    def self.all
+      yaml = YAML.safe_load(File.read('.fitting.yml'))
+      {
+        apis: Fitting::Skip::API.all(yaml['SkipValidation']),
+        actions: Fitting::Skip::Action.all(yaml['SkipValidation'])
+      }
+    end
+
+    def self.find(skips, log)
+      api = Fitting::Skip::API.find(skips[:apis], log)
+      return api if api
+
+      Fitting::Skip::Action.find(skips[:actions], log)
+    end
+  end
+end

data/lib/fitting/version.rb

@@ -1,3 +1,3 @@
 module Fitting
-  VERSION = '3.0.2'.freeze
+  VERSION = '4.0.1'.freeze
 end

data/lib/fitting.rb

@@ -1,35 +1,16 @@
 require 'json-schema'
 require 'fitting/version'
-require 'fitting/configuration'
-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)
+require 'fitting/records/tested/request'
 
 module Fitting
   class << self
-    def configuration
-      yaml = YAML.safe_load(File.read('.fitting.yml'))
-      @configuration ||= Configuration.new(yaml)
-    end
-
-    def configure
-      yield(configuration)
-    end
-
-    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 save_test_data
-      clear_tests_directory
-
-      outgoing_responses = Fitting::Storage::Responses.new
-      responses = Fitting::Storage::Responses.new
-
+    def logger
+      # :nocov:
+      responses = ""
       RSpec.configure do |config|
         if defined?(WebMock)
           config.before(:each) do |example|
@@ -41,17 +22,20 @@ module Fitting
                                                               response.body || {})
               mock_response.instance_variable_set(:@request, mock_request)
 
-              outgoing_responses.add(mock_response, example)
+              request = Fitting::Records::Tested::Request.new(mock_response, example)
+              responses += "FITTING outgoing request #{request.to_spherical.to_json}\n"
             end
           end
         end
 
         config.after(:each, type: :request) do |example|
-          responses.add(response, example)
+          request = Fitting::Records::Tested::Request.new(response, example)
+          responses += "FITTING incoming request #{request.to_spherical.to_json}\n"
         end
 
         config.after(:each, type: :controller) do |example|
-          responses.add(response, example)
+          request = Fitting::Records::Tested::Request.new(response, example)
+          responses += "FITTING incoming request #{request.to_spherical.to_json}\n"
         end
 
         config.after(:each) do
@@ -59,10 +43,10 @@ module Fitting
         end
 
         config.after(:suite) do
-          responses.tests.save
-          outgoing_responses.tests.outgoing_save
+          File.open("log/fitting#{ENV['TEST_ENV_NUMBER']}.log", 'w') { |file| file.write(responses) }
         end
       end
+      # :nocov:
     end
   end
 end

data/lib/tasks/fitting.rake

@@ -1,91 +1,30 @@
-require 'fitting/records/spherical/requests'
-require 'fitting/cover/json_schema'
-require 'fitting/report/prefixes'
-require 'fitting/report/tests'
-require 'fitting/report/console'
+require 'fitting/log'
+require 'fitting/doc'
+require 'fitting/skip'
+require 'fitting/nocov'
+require 'fitting/rep'
+require 'fitting/debug'
 
 namespace :fitting do
-  task :report do
-    tests = Fitting::Report::Tests.new_from_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?
+  task :validate do
+    logs = Fitting::Log.all
+    docs = Fitting::Doc.all
+    skips = Fitting::Skip.all
+
+    logs.each do |log|
+      Fitting::Doc.cover!(docs, log)
+      log.access!
+    rescue Fitting::Doc::NotFound => e
+      next log.pending! if Fitting::Skip.find(skips, log)
+      log.failure!(e)
     end
+    Fitting::Log.report(logs)
 
-    prefixes.to_a.map do |prefix|
-      next if prefix.skip?
-
-      prefix.actions.to_a.map do |action|
-        action.responses.join(action.tests)
-      end
+    Fitting::NoCov.all(YAML.safe_load(File.read('.fitting.yml'))).each do |nocov|
+      nocov.find(docs).nocover!
     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.merge!(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
+    Fitting::Rep.new(docs).save!
+    Fitting::Debug.save!(docs, YAML.safe_load(File.read('.fitting.yml')))
+    Fitting::Doc.report(docs)
   end
 end