fitting 2.2.0 → 2.3.0

data/lib/fitting/records/unit/response.rb

@@ -0,0 +1,31 @@
+require 'fitting/records/unit/json_schema'
+
+module Fitting
+  class Records
+    class Unit
+      class Response
+        def initialize(documented_response, tested_responses)
+          @documented_response = documented_response
+          @tested_responses = tested_responses
+        end
+
+        def status
+          @status ||= @documented_response['status']
+        end
+
+        def json_schemas
+          @json_schemas ||= @documented_response['json_schemas'].inject([]) do |res, documented_json_schema|
+            res.push(Fitting::Records::Unit::JsonSchema.new(documented_json_schema, tested_bodies))
+          end
+        end
+
+        def tested_bodies
+          @tested_bodies ||= @tested_responses.inject([]) do |res, tested_response|
+            next res unless status == tested_response.status.to_s
+            res.push(tested_response.body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fitting/statistics.rb

@@ -1,30 +1,25 @@
-require 'fitting/route'
-require 'fileutils'
+require 'fitting/statistics/template'
 
 module Fitting
   class Statistics
-    def initialize(documentation, all_responses, strict)
-      @documentation = documentation
-      @black_route = Fitting::Route.new(all_responses, @documentation.black, strict)
-      @white_route = Fitting::Route.new(all_responses, @documentation.white, strict)
+    def initialize(tested_requests)
+      @tested_requests = tested_requests
     end
 
     def save
-      FileUtils.mkdir_p 'fitting'
-      File.open('fitting/stats', 'w') { |file| file.write(to_s) }
-      File.open('fitting/not_covered', 'w') { |file| file.write(@white_route.errors) }
-    end
-
-    def to_s
-      if @documentation.black.any?
-        [
-          ['[Black list]', @black_route.statistics_with_conformity_lists].join("\n"),
-          ['[White list]', @white_route.statistics_with_conformity_lists].join("\n"),
-          ''
-        ].join("\n\n")
+      make_dir('fitting')
+      if Fitting.configuration.is_a?(Array)
+        Fitting.configuration.each do |config|
+          make_dir("fitting/#{config.title}")
+          Fitting::Statistics::Template.new(@tested_requests, config).save
+        end
       else
-        [@white_route.statistics_with_conformity_lists, "\n\n"].join
+        Fitting::Statistics::Template.new(@tested_requests, Fitting.configuration).save
       end
     end
+
+    def make_dir(dir_name)
+      FileUtils.mkdir_p(dir_name)
+    end
   end
 end

data/lib/fitting/statistics/analysis.rb

@@ -0,0 +1,24 @@
+require 'fitting/statistics/lists'
+require 'fitting/statistics/requests_stats'
+require 'fitting/statistics/responses_stats'
+require 'fitting/statistics/great'
+require 'fitting/statistics/not_covered_responses'
+
+module Fitting
+  class Statistics
+    class Analysis
+      def initialize(measurement)
+        @measurement = measurement
+      end
+
+      def to_s
+        [
+          Fitting::Statistics::Lists.new(@measurement).to_s,
+          Fitting::Statistics::RequestsStats.new(@measurement).to_s,
+          Fitting::Statistics::ResponsesStats.new(@measurement).to_s,
+          Fitting::Statistics::Great.new(@measurement).to_s
+        ].compact.join("\n\n")
+      end
+    end
+  end
+end

data/lib/fitting/statistics/great.rb

@@ -0,0 +1,13 @@
+module Fitting
+  class Statistics
+    class Great
+      def initialize(measurement)
+        @measurement = measurement
+      end
+
+      def to_s
+        return 'All responses are 100% valid! Great job!' if @measurement.cover_responses == @measurement.all_responses
+      end
+    end
+  end
+end

data/lib/fitting/statistics/list.rb

@@ -0,0 +1,45 @@
+module Fitting
+  class Statistics
+    class List
+      def initialize(coverage, max_response_path)
+        @coverage = coverage
+        @max_response_path = max_response_path
+      end
+
+      def to_s
+        list_sort.inject([]) do |res, request|
+          res.push("#{request.method}\t#{request.path}#{responses_stat(request)}")
+        end.join("\n")
+      end
+
+      def list_sort
+        @coverage.sort do |first, second|
+          first.path.to_s <=> second.path.to_s
+        end
+      end
+
+      def responses_stat(request)
+        tab = "\t" * ((@max_response_path - request.path.to_s.size / 8) + 3)
+        tab + request.responses.to_a.each_with_object([]) do |response, res|
+          response_stat(response, res)
+        end.join(' ')
+      end
+
+      private
+
+      def response_stat(response, res)
+        response.json_schemas.map do |json_schema|
+          json_schema_stat(res, json_schema, response)
+        end
+      end
+
+      def json_schema_stat(res, json_schema, response)
+        if json_schema.bodies == []
+          res.push("✖ #{response.status}")
+        else
+          res.push("✔ #{response.status}")
+        end
+      end
+    end
+  end
+end

data/lib/fitting/statistics/lists.rb

@@ -0,0 +1,52 @@
+require 'fitting/statistics/list'
+
+module Fitting
+  class Statistics
+    class Lists
+      def initialize(measurement)
+        @measurement = measurement
+      end
+
+      def to_s
+        [
+          coverage_fully_stat,
+          coverage_partially_stat,
+          coverage_non_stat
+        ].compact.join("\n\n")
+      end
+
+      def coverage_fully_stat
+        if @measurement.coverage_fully == []
+          nil
+        else
+          [
+            'Fully conforming requests:',
+            Fitting::Statistics::List.new(@measurement.coverage_fully, @measurement.max_response_path).to_s
+          ].join("\n")
+        end
+      end
+
+      def coverage_partially_stat
+        if @measurement.coverage_partially == []
+          nil
+        else
+          [
+            'Partially conforming requests:',
+            Fitting::Statistics::List.new(@measurement.coverage_partially, @measurement.max_response_path).to_s
+          ].join("\n")
+        end
+      end
+
+      def coverage_non_stat
+        if @measurement.coverage_non == []
+          nil
+        else
+          [
+            'Non-conforming requests:',
+            Fitting::Statistics::List.new(@measurement.coverage_non, @measurement.max_response_path).to_s
+          ].join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/fitting/statistics/measurement.rb

@@ -0,0 +1,94 @@
+module Fitting
+  class Statistics
+    class Measurement
+      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)
+
+        if request.path.to_s.size / 8 > @max_response_path
+          @max_response_path = request.path.to_s.size / 8
+        end
+        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.bodies == []
+          @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.bodies == []
+          @not_cover += 1
+        else
+          @cover += 1
+        end
+      end
+    end
+  end
+end

data/lib/fitting/statistics/not_covered_responses.rb

@@ -0,0 +1,13 @@
+module Fitting
+  class Statistics
+    class NotCoveredResponses
+      def initialize(measurement)
+        @measurement = measurement
+      end
+
+      def to_s
+        @measurement.not_covered_responses.join("\n") + "\n"
+      end
+    end
+  end
+end

data/lib/fitting/statistics/percent.rb

@@ -0,0 +1,19 @@
+module Fitting
+  class Statistics
+    class Percent
+      def initialize(divider, dividend)
+        @divider = divider
+        @dividend = dividend
+      end
+
+      def to_f
+        return 0.to_f if @divider.zero?
+        (@dividend.to_f / @divider.to_f * 100.0).round(2)
+      end
+
+      def to_s
+        "#{@dividend} (#{to_f}% of #{@divider})"
+      end
+    end
+  end
+end

data/lib/fitting/statistics/requests_stats.rb

@@ -0,0 +1,40 @@
+require 'fitting/statistics/percent'
+
+module Fitting
+  class Statistics
+    class RequestsStats
+      def initialize(measurement)
+        @measurement = measurement
+      end
+
+      def to_s
+        @to_s ||= [
+          "API requests with fully implemented responses: #{fully}.",
+          "API requests with partially implemented responses: #{partially}.",
+          "API requests with no implemented responses: #{non}."
+        ].join("\n")
+      end
+
+      def fully
+        @fully ||= Fitting::Statistics::Percent.new(
+          @measurement.requests.size,
+          @measurement.coverage_fully.size
+        )
+      end
+
+      def partially
+        @partially ||= Fitting::Statistics::Percent.new(
+          @measurement.requests.size,
+          @measurement.coverage_partially.size
+        )
+      end
+
+      def non
+        @non ||= Fitting::Statistics::Percent.new(
+          @measurement.requests.size,
+          @measurement.coverage_non.size
+        )
+      end
+    end
+  end
+end

data/lib/fitting/statistics/responses_stats.rb

@@ -0,0 +1,32 @@
+require 'fitting/statistics/percent'
+
+module Fitting
+  class Statistics
+    class ResponsesStats
+      def initialize(measurement)
+        @measurement = measurement
+      end
+
+      def to_s
+        @to_s ||= [
+          "API responses conforming to the blueprint: #{cover}.",
+          "API responses with validation errors or untested: #{not_cover}."
+        ].join("\n")
+      end
+
+      def cover
+        @cover ||= Fitting::Statistics::Percent.new(
+          @measurement.all_responses,
+          @measurement.cover_responses
+        )
+      end
+
+      def not_cover
+        @not_cover ||= Fitting::Statistics::Percent.new(
+          @measurement.all_responses,
+          @measurement.not_cover_responses
+        )
+      end
+    end
+  end
+end

data/lib/fitting/statistics/template.rb

@@ -0,0 +1,90 @@
+require 'fitting/statistics/not_covered_responses'
+require 'fitting/statistics/analysis'
+require 'fitting/statistics/measurement'
+require 'fitting/records/unit/request'
+require 'fitting/storage/white_list'
+require 'fitting/records/documented/request'
+
+module Fitting
+  class Statistics
+    class Template
+      def initialize(tested_requests, config)
+        @tested_requests = tested_requests
+        @config = config
+      end
+
+      def save
+        File.open(@config.stats_path, 'w') { |file| file.write(stats) }
+        File.open(@config.not_covered_path, 'w') { |file| file.write(not_covered) }
+      end
+
+      def stats
+        if documented.to_a.size > documented_requests_white.size
+          [
+            ['[Black list]', black_statistics].join("\n"),
+            ['[White list]', white_statistics].join("\n"),
+            ''
+          ].join("\n\n")
+        else
+          [white_statistics, "\n\n"].join
+        end
+      end
+
+      def not_covered
+        Fitting::Statistics::NotCoveredResponses.new(white_measurement).to_s
+      end
+
+      def white_statistics
+        @white_statistics ||= Fitting::Statistics::Analysis.new(white_measurement)
+      end
+
+      def black_statistics
+        @black_statistics ||= Fitting::Statistics::Analysis.new(black_measurement)
+      end
+
+      def white_measurement
+        @white_measurement ||= Fitting::Statistics::Measurement.new(white_unit)
+      end
+
+      def black_measurement
+        @black_measurement ||= Fitting::Statistics::Measurement.new(black_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 black_unit
+        @black_unit_requests ||= documented_requests_black.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_requests_black
+        @documented_requests_black ||= documented.find_all do |request|
+          !request.white
+        end
+      end
+
+      def documented
+        @documented_requests ||= @config.tomogram.to_hash.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.white_list,
+          @config.resource_white_list,
+          @config.tomogram.to_resources
+        )
+      end
+    end
+  end
+end