fitting 2.6.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f803f26bbe2cb7472a2ca8077aa7a00754ec755
-  data.tar.gz: 38f77aec3f07b3aed3f82ebcae34549a953d45f5
+  metadata.gz: 058ccfba8eb94e0929f24473e00684c70d39fe19
+  data.tar.gz: 1a3395ec6ea7e9dd577671a523f85042773a025f
 SHA512:
-  metadata.gz: 3a3619063602e165398a68ea20e4630be7d3877119f11cbead7fdc05a38b4f436e2d06039b75c3d09a55b069498e0f2e043d7acb14151342a90c7282378cc580
-  data.tar.gz: 7c2ec1512bc655dbd816b3ba9665ec6af4bbf7e9c68deb8f3d1f608396ac1e24389bb5099621c732aeb0f895c019cd7e54725e825015bfe8d94829dda00586f1
+  metadata.gz: a6fcea3482af2fec8090fed3306af166d8c98699f18d1c629c13d2f8027fe95a42edf22ffb6ddbe0e15e883e446839450fea817273f18ddb5a0f986912ed9f33
+  data.tar.gz: a4ffbd091060c642052b2d4e5d9d5b33fcd3d3204622d86397b7407a6b8fdcb17527ee74ebe9d6ba759efb41fe3ecee0145b4cac27a80045a6b79fd0b6abed43

data/README.md

@@ -39,30 +39,52 @@ In your `spec_helper.rb`:
 ```ruby
 require 'fitting'
 
-Fitting.statistics
+Fitting.save_test_data
 ```
 
-or
+The tests.json file will be created
 
-```ruby
-require 'fitting'
+Example:
 
-responses = Fitting::Storage::Responses.new
+```
+[
+  {
+    "method": "GET",
+    "path": "/api/v1/book",
+    "body": {},
+    "response": {
+      "status": 200,
+      "body": {
+        "title": "The Martian Chronicles"
+      }
+    },
+    "title": "/spec/controllers/api/v1/books_controller_spec.rb:11",
+    "group": "/spec/controllers/api/v1/books_controller_spec.rb"
+  },
+  {
+    "method": "POST",
+    "path": "/api/v1/book",
+    "body": {},
+    "response": {
+      "status": 200,
+      "body": {
+        "title": "The Old Man and the Sea"
+      }
+    },
+    "title": "/spec/controllers/api/v1/books_controller_spec.rb:22",
+    "group": "/spec/controllers/api/v1/books_controller_spec.rb"
+  },
+  ...
+```
 
-RSpec.configure do |config|
-  config.after(:each, type: :controller) do
-    responses.add(response)
-  end
 
-  config.after(:suite) do
-    responses.statistics.save
-  end
-end
-```
+## Check documentation cover
+
+### xs size
 
-## Example output
+For match routes and valid json-schemas run `rake fitting:documentation_responses[xs]`
 
-After running tests you will get statistics in the file `fitting/stats`:
+You will get statistics:
 
 ```
 Fully conforming requests:
@@ -88,31 +110,50 @@ API responses conforming to the blueprint: 16 (64.00% of 25).
 API responses with validation errors or untested: 9 (36.00% of 25).
 ```
 
-Also you will get not covered responses in the file `fitting/not_covered`.
-
-## Matchers
+### s size
 
-If you want to know why you get crosses instead of checkmarks you can use matchers for RSpec.
+In addition to the previous comand, you will learn the coverage json-schemas with task `rake fitting:documentation_responses[s]`
 
-```ruby
-config.include Fitting::Matchers, type: :controller
 ```
+Fully conforming requests:
+DELETE  /api/v1/book                 100% 200 100% 201 100% 404
+DELETE  /api/v1/book/{id}            100% 200 100% 201 100% 404
+GET     /api/v1/book/{id}/seller     100% 200 100% 201 100% 404
 
-### match_schema
+Partially conforming requests:
+GET     /api/v1/book                 0% 200 66% 404
+POST    /api/v1/book                 0% 200 90% 201 100% 404
+GET     /api/v1/book/{id}            0% 200 88% 404 10% 200
+PATCH   /api/v1/book/{id}            0% 200 100% 201 10% 404
 
-Makes a simple validation against JSON Schema.
+Non-conforming requests:
+GET     /api/v1/seller               0% 200 0% 201 0 404
+GET     /api/v1/buyer                0% 200 0% 404
 
-```ruby
-expect(response).to match_schema
-```
+API requests with fully implemented responses: 3 (33.33% of 9).
+API requests with partially implemented responses: 4 (44.44% of 9).
+API requests with no implemented responses: 2 (22.22% of 9).
 
-### strictly_match_schema
+API responses conforming to the blueprint: 16 (64.00% of 25).
+API responses with validation errors or untested: 9 (36.00% of 25).
+```
 
-Makes a strict validation against JSON Schema. All properties are considered to have `"required": true` and all objects `"additionalProperties": false`.
+For details `rake fitting:documentation_responses_error[s]`
 
-```ruby
-expect(response).to strictly_match_schema
 ```
+request metohd: GET
+request path: /api/v1/book
+response staus: 200
+source json-schema: {"$schema"=>"http://json-schema.org/draft-04/schema#", "type"=>"object", ...}
+combination: ["required", "pages"]
+new json-schema: {"$schema"=>"http://json-schema.org/draft-04/schema#", "type"=>"object", ...}
+```
+
+## Check tests cover
+
+### xs size
+
+`rake fitting:tests_responses[xs]`
 
 ## Config
 
@@ -176,6 +217,11 @@ resource_white_list:
 
 Empty array `[]` means all methods.
 
+### json_schema_cover
+
+Default: false. Json-schema covering becomes mandatory.
+Or you can call `responses.statistics.cover_save` if you don't use call `Fitting.statistics`.
+
 ### include_resources
 
 Default: all resources if  `include_resources` and `include_actions` is not used.

data/fitting.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'json-schema', '~> 2.6', '>= 2.6.2'
   spec.add_runtime_dependency 'multi_json'
   spec.add_runtime_dependency 'tomograph', '~> 2.0', '>= 2.2.0'
+  spec.add_runtime_dependency 'haml'
   spec.add_development_dependency 'bundler', '~> 1.12'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'byebug', '~> 8.2', '>= 8.2.1'

data/lib/fitting/cover.rb

@@ -0,0 +1,66 @@
+require 'fitting/cover/response'
+require 'haml'
+require 'json'
+
+module Fitting
+  class Cover
+    def initialize(all_responses, coverage)
+      @all_responses = all_responses
+      @coverage = coverage
+      @list = {}
+    end
+
+    def to_hash
+      return @list unless @list == {}
+      @all_responses.each_with_object({}) do |response, res|
+        next res unless response.documented?
+        if res.key?(response.route)
+          res[response.route].update(response)
+        else
+          res[response.route] = Fitting::Cover::Response.new(response)
+        end
+      end.map do |key, value|
+        @list[key] = value.to_hash
+      end
+      @list
+    end
+
+    def template
+      return @template if @template
+      @template = {}
+      to_hash.each do |key, value|
+        @template[key] = value
+        @template[key]['cover'] = 100.0
+        if value['flags'] == []
+          @template[key]['type'] = 'passed'
+        else
+          flag_true = value['flags'].find_all{|flag| flag == true}
+          flag_false = value['flags'].find_all{|flag| flag == false}
+          if flag_false.size == 0
+            @template[key]['type'] = 'passed'
+          else
+            if flag_true.size == 0
+              @template[key]['cover'] = 0.0
+            else
+              @template[key]['cover'] = flag_false.size / flag_true.size
+            end
+            @template[key]['type'] = 'failed'
+          end
+        end
+        @template[key]['json_schema'] = JSON.pretty_generate(value['json_schemas'].last)
+      end
+      @template
+    end
+
+    def save
+      to_hash
+      contents = File.read(File.expand_path('../view/report.html.haml', __FILE__))
+      html = "<style>\n#{File.read(File.expand_path('../view/style.css', __FILE__))}\n</style>\n"
+      html += Haml::Engine.new(contents).render(
+        Object.new,
+        :@to_hash => template
+      )
+      html
+    end
+  end
+end

data/lib/fitting/cover/json_schema.rb

@@ -0,0 +1,106 @@
+module Fitting
+  class Cover
+    class JSONSchema
+      def initialize(json_schema)
+        @json_schema = json_schema
+      end
+
+      def json_schemas
+        return @json_schemas if @json_schemas
+        @json_schemas, @combinations = required(@json_schema)
+
+        return @json_schemas unless @json_schema['properties']
+        super_each(@json_schema['properties'], 'properties' => nil)
+
+        @json_schemas
+      end
+
+      def super_each(json_schema, old_keys_hash)
+        json_schema.each do |key, value|
+          new_keys_hash = clone_hash(old_keys_hash)
+          add_super_key(new_keys_hash, key)
+          if value.is_a?(Hash)
+            modify_json_shema(value, new_keys_hash)
+            super_each(value, new_keys_hash)
+          end
+        end
+      end
+
+      def add_super_key(vbn, new_key)
+        vbn.each do |key, value|
+          if value
+            add_super_key(value, new_key)
+          else
+            vbn[key] = { new_key => nil }
+          end
+        end
+      end
+
+      def super_merge(vbn, asd, old_json_schema)
+        vbn.each do |key, value|
+          if value
+            super_merge(value, asd, old_json_schema[key])
+          else
+            old_json_schema[key].merge!(asd)
+          end
+        end
+        old_json_schema
+      end
+
+      def modify_json_shema(value, vbn)
+        qwe = required(value)
+        qwe[0].map do |asd|
+          new_json_shema = clone_hash(@json_schema)
+          super_merge(vbn, asd, new_json_shema)
+          @json_schemas += [new_json_shema]
+        end
+        @combinations += qwe[1]
+      end
+
+      def clone_hash(old_json_schema)
+        new_json_schema = {}
+        old_json_schema.each do |key, value|
+          if value.is_a?(Hash)
+            new_json_schema.merge!(key => clone_hash(value))
+          elsif value
+            new_json_schema.merge!(key => value.clone)
+          else
+            new_json_schema.merge!(key => nil)
+          end
+        end
+        new_json_schema
+      end
+
+      def combinations
+        json_schemas
+        @combinations
+      end
+
+      def required(json_schema)
+        combinations = []
+        json_schemas = new_keys(json_schema).inject([]) do |new_json_shemas, new_key|
+          new_json_shema = json_schema.dup
+          if new_json_shema['required']
+            new_json_shema['required'] += [new_key]
+          else
+            new_json_shema['required'] = [new_key]
+          end
+          combinations.push(['required', new_key])
+          new_json_shemas.push(new_json_shema)
+        end
+        [json_schemas, combinations]
+      end
+
+      def new_keys(json_schema)
+        return [] unless json_schema && json_schema['properties']
+        all = json_schema['properties'].keys.map(&:to_s)
+        old = json_schema['required']
+        if old
+          all - old
+        else
+          all
+        end
+      end
+    end
+  end
+end

data/lib/fitting/cover/response.rb

@@ -0,0 +1,41 @@
+require 'fitting/cover/json_schema'
+require 'json-schema'
+
+module Fitting
+  class Cover
+    class Response
+      def initialize(response)
+        @cover_json_schemas = Fitting::Cover::JSONSchema.new(response.json_schema)
+        @json_schemas = @cover_json_schemas.json_schemas + [response.json_schema]
+        @combinations = @cover_json_schemas.combinations
+        @flags = @cover_json_schemas.json_schemas.map do |json_schema|
+          JSON::Validator.validate(json_schema, response.body)
+        end
+      end
+
+      attr_reader :json_schemas
+
+      attr_reader :combinations
+
+      attr_reader :flags
+
+      def update(response)
+        index = 0
+        @cover_json_schemas.json_schemas.map do |json_schema|
+          flag = JSON::Validator.validate(json_schema, response.body)
+          @flags[index] = @flags[index] || flag
+          index += 1
+        end
+        self
+      end
+
+      def to_hash
+        {
+          'json_schemas' => json_schemas,
+          'combinations' => combinations,
+          'flags' => flags
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'json-schema'
+
+module Fitting
+  class Records
+    class Unit
+      class Combination
+        attr_reader :description, :json_schema, :bodies
+
+        def initialize(description, json_schema, bodies)
+          @description = description
+          @json_schema = json_schema
+          @bodies = bodies
+        end
+
+        def valid_bodies
+          @valid_bodies ||= @bodies.inject([]) do |res, tested_body|
+            begin
+              next res unless JSON::Validator.validate(@json_schema, tested_body)
+              res.push(tested_body)
+            rescue JSON::Schema::UriError
+              res.push(tested_body)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,13 @@
 require 'json-schema'
+require 'fitting/cover/json_schema'
+require 'fitting/records/unit/combination'
 
 module Fitting
   class Records
     class Unit
       class JsonSchema
+        attr_reader :json_schema
+
         def initialize(json_schema, tested_bodies)
           @json_schema = json_schema
           @tested_bodies = tested_bodies
@@ -19,6 +23,32 @@ module Fitting
             end
           end
         end
+
+        def combinations
+          return @combinations if @combinations
+          @combinations = []
+          cover_json_schema = Fitting::Cover::JSONSchema.new(@json_schema)
+          cover_json_schema.json_schemas.each_index do |index|
+             @combinations.push(Fitting::Records::Unit::Combination.new(
+              cover_json_schema.combinations[index],
+              cover_json_schema.json_schemas[index],
+              bodies
+            ))
+          end
+          @combinations
+        end
+
+        def cover
+          @cover ||= if bodies == []
+                       0
+                     else
+                       count = 0
+                       combinations.map do |combination|
+                         count += 1 unless combination.valid_bodies == []
+                       end
+                       (count + 1) * 100 / (combinations.size + 1)
+                     end
+        end
       end
     end
   end

data/lib/fitting/response.rb

@@ -5,6 +5,8 @@ require 'multi_json'
 
 module Fitting
   class Response
+    attr_reader :body
+
     def initialize(env_response, tomogram)
       @request = Fitting::Request.new(env_response.request, tomogram)
       @status = env_response.status
@@ -54,6 +56,10 @@ module Fitting
       end.join("\n\n")
     end
 
+    def json_schema
+      @schemas[index.first]
+    end
+
     def ignored?(ignore_list)
       @request.ignored?(ignore_list)
     end

data/lib/fitting/statistics/analysis.rb

@@ -7,13 +7,14 @@ require 'fitting/statistics/not_covered_responses'
 module Fitting
   class Statistics
     class Analysis
-      def initialize(measurement)
+      def initialize(measurement, depth)
         @measurement = measurement
+        @depth = depth
       end
 
       def to_s
         [
-          Fitting::Statistics::Lists.new(@measurement).to_s,
+          Fitting::Statistics::Lists.new(@measurement, @depth).to_s,
           Fitting::Statistics::RequestsStats.new(@measurement).to_s,
           Fitting::Statistics::ResponsesStats.new(@measurement).to_s,
           Fitting::Statistics::Great.new(@measurement).to_s

data/lib/fitting/statistics/cover_error.rb

@@ -0,0 +1,31 @@
+module Fitting
+  class Statistics
+    class CoverError
+      def initialize(request_unit)
+        @request_unit = request_unit
+      end
+
+      def to_s
+        res = ''
+        @request_unit.map do |request|
+          request.responses.map do |response|
+            if response.tested_bodies == []
+              return 'Error, not all responses valid without cover!'
+            else
+              response.json_schemas.map do |json_schema|
+                json_schema.combinations.map do |combination|
+                  if combination.valid_bodies == []
+                    res += "request metohd: #{request.method}\nrequest path: #{request.path}\n"\
+                            "response staus: #{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
+          end
+        end
+        res
+      end
+    end
+  end
+end

data/lib/fitting/statistics/list.rb

@@ -1,9 +1,10 @@
 module Fitting
   class Statistics
     class List
-      def initialize(coverage, max_response_path)
+      def initialize(coverage, max_response_path, depth)
         @coverage = coverage
         @max_response_path = max_response_path
+        @depth = depth
       end
 
       def to_s
@@ -34,10 +35,14 @@ module Fitting
       end
 
       def json_schema_stat(res, json_schema, response)
-        if json_schema.bodies == []
-          res.push("✖ #{response.status}")
+        if @depth == 'valid'
+          if json_schema.bodies == []
+            res.push("✖ #{response.status}")
+          else
+            res.push("✔ #{response.status}")
+          end
         else
-          res.push("✔ #{response.status}")
+          res.push("#{json_schema.cover}% #{response.status}")
         end
       end
     end

data/lib/fitting/statistics/lists.rb

@@ -3,8 +3,9 @@ require 'fitting/statistics/list'
 module Fitting
   class Statistics
     class Lists
-      def initialize(measurement)
+      def initialize(measurement, depth)
         @measurement = measurement
+        @depth = depth
       end
 
       def to_s
@@ -21,7 +22,7 @@ module Fitting
         else
           [
             'Fully conforming requests:',
-            Fitting::Statistics::List.new(@measurement.coverage_fully, @measurement.max_response_path).to_s
+            Fitting::Statistics::List.new(@measurement.coverage_fully, @measurement.max_response_path, @depth).to_s
           ].join("\n")
         end
       end
@@ -32,7 +33,7 @@ module Fitting
         else
           [
             'Partially conforming requests:',
-            Fitting::Statistics::List.new(@measurement.coverage_partially, @measurement.max_response_path).to_s
+            Fitting::Statistics::List.new(@measurement.coverage_partially, @measurement.max_response_path, @depth).to_s
           ].join("\n")
         end
       end
@@ -43,7 +44,7 @@ module Fitting
         else
           [
             'Non-conforming requests:',
-            Fitting::Statistics::List.new(@measurement.coverage_non, @measurement.max_response_path).to_s
+            Fitting::Statistics::List.new(@measurement.coverage_non, @measurement.max_response_path, @depth).to_s
           ].join("\n")
         end
       end

data/lib/fitting/statistics/measurement_cover.rb

@@ -0,0 +1,94 @@
+module Fitting
+  class Statistics
+    class MeasurementCover
+      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.cover != 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 != 100
+          @not_cover += 1
+        else
+          @cover += 1
+        end
+      end
+    end
+  end
+end

data/lib/fitting/statistics/template.rb

@@ -1,6 +1,7 @@
 require 'fitting/statistics/not_covered_responses'
 require 'fitting/statistics/analysis'
 require 'fitting/statistics/measurement'
+require 'fitting/statistics/measurement_cover'
 require 'fitting/records/unit/request'
 require 'fitting/storage/white_list'
 require 'fitting/records/documented/request'
@@ -8,9 +9,10 @@ require 'fitting/records/documented/request'
 module Fitting
   class Statistics
     class Template
-      def initialize(tested_requests, config)
+      def initialize(tested_requests, config, depth = 'valid')
         @tested_requests = tested_requests
         @config = config
+        @depth = depth
       end
 
       def save
@@ -35,19 +37,29 @@ module Fitting
       end
 
       def white_statistics
-        @white_statistics ||= Fitting::Statistics::Analysis.new(white_measurement)
+        @white_statistics ||= Fitting::Statistics::Analysis.new(white_measurement, @depth)
       end
 
       def black_statistics
-        @black_statistics ||= Fitting::Statistics::Analysis.new(black_measurement)
+        @black_statistics ||= Fitting::Statistics::Analysis.new(black_measurement, @depth)
       end
 
       def white_measurement
-        @white_measurement ||= Fitting::Statistics::Measurement.new(white_unit)
+        @white_measurement ||=
+          if @depth == 'valid'
+            Fitting::Statistics::Measurement.new(white_unit)
+          else
+            Fitting::Statistics::MeasurementCover.new(white_unit)
+          end
       end
 
       def black_measurement
-        @black_measurement ||= Fitting::Statistics::Measurement.new(black_unit)
+        @black_measurement ||=
+          if @depth == 'valid'
+            Fitting::Statistics::Measurement.new(black_unit)
+          else
+            Fitting::Statistics::MeasurementCover.new(black_unit)
+          end
       end
 
       def white_unit

data/lib/fitting/statistics/template_cover_error.rb

@@ -0,0 +1,54 @@
+require 'fitting/statistics/cover_error'
+require 'fitting/records/unit/request'
+require 'fitting/storage/white_list'
+require 'fitting/records/documented/request'
+
+module Fitting
+  class Statistics
+    class TemplateCoverError
+      def initialize(tested_requests, config)
+        @tested_requests = tested_requests
+        @config = config
+      end
+
+      def stats
+        [
+          ['[White list]', white_statistics].join("\n"),
+          ''
+        ].join("\n\n")
+      end
+
+
+      def white_statistics
+        @white_statistics ||= Fitting::Statistics::CoverError.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/version.rb

@@ -1,3 +1,3 @@
 module Fitting
-  VERSION = '2.6.0'.freeze
+  VERSION = '2.7.0'.freeze
 end

data/lib/fitting/view/report.html.haml

@@ -0,0 +1,16 @@
+!!! 5
+%html
+  %head
+    %title= Time.now
+    %meta{charset: "utf-8"}
+  %body
+    - @to_hash.each do |key, value|
+      %details
+        %summary{class: "collapse #{value['type']}"}
+          = "#{key} #{value['cover']}"
+        %div{class: 'group'}
+          %div{class: 'section'}
+            %div
+              %b main json-schema
+              %xmp
+                = value['json_schema']

data/lib/fitting/view/style.css

@@ -0,0 +1,47 @@
+summary {
+    margin: 10px;
+}
+
+summary:hover {
+    background: #e1e1e1;
+}
+
+.passed {
+    color: green;
+}
+
+.failed {
+    color: red;
+}
+
+.pending {
+    color: orange;
+}
+
+.collapse {
+    cursor: pointer;
+    display: block;
+    background: white;
+}
+
+.collapse + input {
+    display: none; /* hide the checkboxes */
+}
+
+.collapse + input + div {
+    display: none;
+}
+
+.collapse + input:checked + div {
+    display: block;
+}
+
+.section {
+    padding-top: 10px;
+}
+
+.group {
+    border: 1px solid black;
+    margin: 5px 0px;
+    padding: 0px 5px;
+}

data/lib/tasks/fitting.rake

@@ -2,6 +2,7 @@ require 'fitting/records/spherical/requests'
 require 'fitting/configuration'
 require 'fitting/records/realized_unit'
 require 'fitting/templates/realized_template'
+require 'fitting/statistics/template_cover_error'
 
 namespace :fitting do
   desc 'Fitting documentation'
@@ -18,6 +19,49 @@ namespace :fitting do
     end
   end
 
+  desc 'Fitting documentation responses cover'
+  task :documentation_responses, [:size] => :environment do |_, args|
+    if args.size == '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
+    elsif args.size == '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
+    else
+      puts 'need key xs or s'
+    end
+  end
+
+  desc 'Fitting documentation responses cover error'
+  task :documentation_responses_error, [:size] => :environment do |_, args|
+    if args.size == 's'
+      documented_unit = Fitting::Statistics::TemplateCoverError.new(
+        Fitting::Records::Spherical::Requests.new,
+        Fitting.configuration
+      )
+      puts documented_unit.stats
+    else
+      puts 'need key s'
+    end
+  end
+
   desc 'Fitting tests'
   task :tests do
     realized_unit = Fitting::Records::RealizedUnit.new(
@@ -31,4 +75,22 @@ namespace :fitting do
       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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fitting
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 2.7.0
 platform: ruby
 authors:
 - d.efimov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-28 00:00:00.000000000 Z
+date: 2018-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -64,6 +64,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -195,6 +209,9 @@ files:
 - lib/fitting/configuration.rb
 - lib/fitting/configuration/legacy.rb
 - lib/fitting/configuration/yaml.rb
+- lib/fitting/cover.rb
+- lib/fitting/cover/json_schema.rb
+- lib/fitting/cover/response.rb
 - lib/fitting/documentation.rb
 - lib/fitting/matchers/response_matcher.rb
 - lib/fitting/railtie.rb
@@ -206,6 +223,7 @@ files:
 - lib/fitting/records/test_unit/request.rb
 - lib/fitting/records/tested/request.rb
 - lib/fitting/records/tested/response.rb
+- lib/fitting/records/unit/combination.rb
 - lib/fitting/records/unit/json_schema.rb
 - lib/fitting/records/unit/request.rb
 - lib/fitting/records/unit/response.rb
@@ -214,20 +232,25 @@ files:
 - lib/fitting/response/fully_validates.rb
 - lib/fitting/statistics.rb
 - lib/fitting/statistics/analysis.rb
+- lib/fitting/statistics/cover_error.rb
 - lib/fitting/statistics/great.rb
 - lib/fitting/statistics/list.rb
 - lib/fitting/statistics/lists.rb
 - lib/fitting/statistics/measurement.rb
+- lib/fitting/statistics/measurement_cover.rb
 - lib/fitting/statistics/not_covered_responses.rb
 - lib/fitting/statistics/percent.rb
 - lib/fitting/statistics/requests_stats.rb
 - lib/fitting/statistics/responses_stats.rb
 - lib/fitting/statistics/template.rb
+- lib/fitting/statistics/template_cover_error.rb
 - lib/fitting/storage/responses.rb
 - lib/fitting/storage/white_list.rb
 - lib/fitting/templates/realized_template.rb
 - lib/fitting/tests.rb
 - lib/fitting/version.rb
+- lib/fitting/view/report.html.haml
+- lib/fitting/view/style.css
 - lib/tasks/fitting.rake
 homepage: https://github.com/funbox/fitting
 licenses: