routes_coverage 0.5.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b8b13d46985bf003169ae46c148f11a0601baae2d06281553d5baf307b9a80b
-  data.tar.gz: 9cd59c55dae847b403d6d46cae8e0a98e0a3cb584a69887e80bc78369138a748
+  metadata.gz: 4f992227e3172a9ee4ea678d302b2d6655cdf16feed78020947375cc627a0254
+  data.tar.gz: 4f5dae5790bac97b3675d085d771a17175e8744f00fed659625592dc471c8a27
 SHA512:
-  metadata.gz: 91e649e374663f6c6e8ac187eb452b0ea3117037fbf51f92216aa4789ad64828e744fa1ba6e677c4e77b4062a50125df03bf3099866abc6fa6871d557d333168
-  data.tar.gz: 3230aa30d9332d6df0b7b3549ad8b1b22b34934da67db613cbf74b0288982125523c1c073cda0587383224f7610a7ac070953ccd79aa3e622d5e638683c51f8c
+  metadata.gz: 97e2aaf45f30572215e26fe51370257f00ee92129c38404050f569d5faf3d290690ddd1f5b5022c366edbb09b3b3fe5b16e9c6a50814ce86c2a4d6fc313d8be0
+  data.tar.gz: 432330b7f4a1641f03bb9bcfed7dc2a85868a2b6637cc2ba3015454471f1bc7a33889730feb7fdb8257b0456a536defbceeff320c88a899d4dd19500882fe2f4

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## Unreleased
+
+-
+
+## 0.7.0
+
+- Support for Rails 7 (added tests, main code was already working)
+- Fixed: errors on Rails 3 and ruby 2.3
+- New feature: `require 'routes_coverage/auditor'; RoutesCoverage::Auditor.new.print_missing_actions` detects actions present in routes, but not present in controllers.
+  `print_unused_actions` - the other direction. Useful for routes cleanup.
+
+- Known bug: collecting coverage data from engines is still not supported :(
+
+## <= 0.6.0
+
+In commit history, sorry

data/README.md

@@ -37,6 +37,7 @@ RSpec.configure do |config|
   config.routes_coverage.perform_report = ENV['ROUTES_COVERAGE'] # only generate report if env var is set
 
   config.routes_coverage.exclude_put_fallbacks = true # exclude non-hit PUT-requests where a matching PATCH exists
+  config.routes_coverage.include_from_controller_tests = true # include results from controller tests
   config.routes_coverage.exclude_patterns << %r{PATCH /reqs}   # excludes all requests matching regex
   config.routes_coverage.exclude_namespaces << 'somenamespace' # excludes /somenamespace/*
 
@@ -70,7 +71,9 @@ or
 RoutesCoverage.settings.format = :full_text
 ```
 
-
+Note that coverage from `include_from_controller_tests` (disabled by default) is not a true routes coverage.
+Rounting is not tested in controller tests (which are deprecated in Rails 5),
+but sometimes you may already have a lot of controller tests and an intent to improve green-path/business level coverage
 
 ## Development
 

data/lib/routes_coverage/auditor.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RoutesCoverage
+  class Auditor
+    def logger
+      @logger ||= Logger.new($stdout).tap do |log|
+        log.formatter = ->(_severity, _datetime, _progname, msg) { "#{msg}\n" }
+      end
+    end
+
+    def controllers
+      @controllers ||= begin
+        logger.info "Eager-loading app to collect controllers"
+        Rails.application.eager_load!
+
+        logger.info "Collecting controllers"
+        if defined?(ActionController::API)
+          ActionController::Base.descendants + ActionController::API.descendants
+        else
+          # older rails
+          ActionController::Base.descendants
+        end
+      end
+    end
+
+    def controllers_hash
+      @controllers_hash ||= controllers.index_by { |controller| controller.name.sub(/Controller$/, "").underscore }
+    end
+
+    def controller_class_by_name(controller_name)
+      controller = controllers_hash[controller_name]
+      return controller if controller
+
+      @missing_controllers ||= Set.new
+      return if @missing_controllers.include?(controller_name)
+
+      controllers_hash[controller_name] ||= "#{controller_name}_controller".classify.constantize
+      logger.warn "Controller #{controller_name} was not collected, but exists"
+      controllers_hash[controller_name]
+    rescue ArgumentError => e
+      @missing_controllers << controller_name
+      logger.warn "Controller #{controller_name} failed to load: #{e}"
+      nil
+    rescue NameError
+      @missing_controllers << controller_name
+      logger.warn "Controller #{controller_name} looks not existing"
+      nil
+    end
+
+    def existing_actions_usage_hash
+      @existing_actions_usage_hash ||= begin
+        logger.info "Collecting actions"
+        controller_actions = controllers.map do |controller|
+          # cannot use controller.controller_name - it has no namespace, same thing without demodulize:
+          controller_name = controller.name.sub(/Controller$/, "").underscore
+          controller.action_methods.map { |action| "#{controller_name}##{action}" }
+        end
+        controller_actions.flatten.map { |action| [action, 0] }.to_h
+      end
+    end
+
+    def all_routes
+      # NB: there're no engines
+      @all_routes ||= RoutesCoverage._collect_all_routes
+    end
+
+    def perform
+      require 'routes_coverage'
+      routes = all_routes
+
+      @missing_actions = Hash.new(0)
+      @existing_actions_usage_hash = nil
+      routes.each do |route|
+        next unless route.respond_to?(:requirements) && route.requirements[:controller]
+
+        action = "#{route.requirements[:controller]}##{route.requirements[:action]}"
+        if existing_actions_usage_hash[action]
+          existing_actions_usage_hash[action] += 1
+        else
+          # there may be inheritance or implicit renders
+          controller_instance = controller_class_by_name(route.requirements[:controller])&.new
+          unless controller_instance&.available_action?(route.requirements[:action])
+            if controller_instance.respond_to?(route.requirements[:action])
+              logger.warn "No action, but responds: #{action}"
+            end
+            @missing_actions[action] += 1
+          end
+        end
+      end
+    end
+
+    def missing_actions
+      perform unless @missing_actions
+      @missing_actions
+    end
+
+    def unused_actions
+      perform unless @existing_actions_usage_hash
+
+      root = "#{Rails.root}/" # rubocop:disable Rails/FilePath
+      @unused_actions ||= begin
+        # methods with special suffixes are obviously not actions, reduce noise:
+        unused_actions_from_hash = existing_actions_usage_hash.reject do |action, count|
+          count.positive? || action.end_with?('?') || action.end_with?('!') || action.end_with?('=')
+        end
+
+        unused_actions_from_hash.keys.map do |action|
+          controller_name, action_name = action.split('#', 2)
+          controller = controller_class_by_name(controller_name)&.new
+          method = controller.method(action_name.to_sym)
+          if method&.source_location && method.source_location.first.start_with?(root)
+            "#{method.source_location.first.sub(root, '')}:#{method.source_location.second} - #{action}"
+          else
+            action
+          end
+        end.uniq.sort
+      end
+    end
+
+    def print_missing_actions
+      logger.info "\nMissing #{missing_actions.count} actions:"
+
+      # NB: for singular `resource` there may be unnecessary `index` in suggestions
+      restful_actions = %w[index new create show edit update destroy].freeze
+
+      declared_restful = all_routes.select { |route|
+        route.respond_to?(:requirements) && route.requirements[:controller] &&
+        restful_actions.include?(route.requirements[:action])
+      }.group_by{ |route| route.requirements[:controller]}
+
+      missing_actions.keys.map { |action| action.split('#', 2) }.group_by(&:first).each do |(controller, actions)|
+        missing = actions.map(&:last)
+        next if missing.empty?
+
+        undeclared_restful = restful_actions - declared_restful[controller].map{|r| r.requirements[:action] }
+        logger.info([
+          "#{controller}:",
+          (if (restful_actions & missing).any?
+            "#{(missing & restful_actions).join(', ')}"\
+            ", except: %i[#{(restful_actions & (missing + undeclared_restful)).join(' ')}]"\
+            ", only: %i[#{(restful_actions - (missing + undeclared_restful)).join(' ')}]"
+          end),
+          (if (missing - restful_actions).any?
+            ",  Missing custom: #{(missing - restful_actions).join(', ')}"
+          end)
+
+        ].compact.join(' '))
+      end
+    end
+
+    def print_unused_actions
+      logger.info "Unused #{unused_actions.count} actions:"
+      unused_actions.each { |action| logger.info action }
+    end
+  end
+end

data/lib/routes_coverage/middleware.rb

@@ -9,27 +9,9 @@ module RoutesCoverage
     def call(original_env)
       # router changes env/request during recognition so need a copy:
       env = original_env.dup
-      req = ::Rails.application.routes.request_class.new env
-      ::Rails.application.routes.router.recognize(req) do |route, parameters5, parameters4|
-        parameters = parameters5 || parameters4
-        dispatcher = route.app
-        if dispatcher.respond_to?(:dispatcher?)
-          req.path_parameters = parameters
-          dispatcher = nil unless dispatcher.matches?(req) # && dispatcher.dispatcher?
-        else # rails < 4.2
-          dispatcher = route.app
-          req.env['action_dispatch.request.path_parameters'] =
-            (env['action_dispatch.request.path_parameters'] || {}).merge(parameters)
-          while dispatcher.is_a?(ActionDispatch::Routing::Mapper::Constraints)
-            dispatcher = (dispatcher.app if dispatcher.matches?(env))
-          end
-        end
-        next unless dispatcher
+      req = ::Rails.application.routes.request_class.new(env)
+      RoutesCoverage._touch_request(req)
 
-        RoutesCoverage._touch_route(route)
-        # there may be multiple matching routes - we should match only first
-        break
-      end
       # TODO: detect 404s? and maybe other route errors?
       @app.call(original_env)
     end

data/lib/routes_coverage/result.rb

@@ -90,20 +90,22 @@ module RoutesCoverage
     attr_reader :all_routes, :route_hit_counts
 
     def expected_routes
-      return @expected_routes if @expected_routes
-
-      filter_regex = Regexp.union(@settings.exclude_patterns)
-      namespaces_regex = Regexp.union(@settings.exclude_namespaces.map { |n| %r{^/#{n}} })
+      @expected_routes ||= begin
+        filter_regex = Regexp.union(@settings.exclude_patterns)
+        namespaces_regex = Regexp.union(@settings.exclude_namespaces.map { |n| %r{^/#{n}} })
+
+        routes_groups = all_routes.group_by do |r|
+          # rails <=4 has regex in verb
+          verb = r.verb.is_a?(Regexp) && r.verb.inspect.gsub(/[^\w]/, '') || r.verb
+          (
+            ("#{verb} #{r.path.spec}".strip =~ filter_regex) ||
+            (r.path.spec.to_s =~ namespaces_regex)
+          ).present?
+        end
 
-      routes_groups = all_routes.group_by do |r|
-        (
-          ("#{r.verb.to_s[8..-3]} #{r.path.spec}".strip =~ filter_regex) ||
-          (r.path.spec.to_s =~ namespaces_regex)
-        ).present?
+        @excluded_routes = routes_groups[true] || []
+        routes_groups[false] || []
       end
-
-      @excluded_routes = routes_groups[true] || []
-      @expected_routes = routes_groups[false] || []
     end
 
     def pending_routes

data/lib/routes_coverage/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RoutesCoverage
-  VERSION = "0.5.1"
+  VERSION = "0.7.0"
 end

data/lib/routes_coverage.rb

@@ -10,17 +10,43 @@ require "routes_coverage/formatters/full_text"
 require "routes_coverage/formatters/html"
 
 module RoutesCoverage
+  module ActionControllerTestCase
+    def process(action, *args)
+      return super unless RoutesCoverage.settings.include_from_controller_tests
+
+      super.tap { RoutesCoverage._touch_request(@request) }
+    end
+  end
+
+  module ActionControllerTestCaseKvargs
+    def process(action, **kvargs)
+      return super unless RoutesCoverage.settings.include_from_controller_tests
+
+      super.tap { RoutesCoverage._touch_request(@request) }
+    end
+  end
+
   class Railtie < ::Rails::Railtie
     railtie_name :routes_coverage
 
     initializer "request_coverage.inject_test_middleware" do
       ::Rails.application.middleware.use RoutesCoverage::Middleware if RoutesCoverage.enabled?
+
+      ActiveSupport.on_load(:action_controller_test_case) do |klass|
+        if Rails.version >= '5.1'
+          klass.prepend RoutesCoverage::ActionControllerTestCaseKvargs
+        else
+          klass.prepend RoutesCoverage::ActionControllerTestCase
+        end
+      end
     end
   end
 
   class Settings
     attr_reader :exclude_patterns, :exclude_namespaces, :groups
-    attr_accessor :exclude_put_fallbacks, :perform_report, :minimum_coverage, :round_precision, :format
+    attr_accessor :perform_report, :format, :minimum_coverage, :round_precision,
+                  :exclude_put_fallbacks,
+                  :include_from_controller_tests
 
     def initialize
       @exclude_patterns = []
@@ -90,7 +116,7 @@ module RoutesCoverage
       end
 
       if ungroupped_routes.any?
-        groups["Ungroupped"] = Result.new(ungroupped_routes, route_hit_count.slice(ungroupped_routes), settings)
+        groups["Ungroupped"] = Result.new(ungroupped_routes, route_hit_count.slice(*ungroupped_routes), settings)
       end
     end
 
@@ -144,7 +170,7 @@ module RoutesCoverage
             when :constraints
               value.all? do |constraint_name, constraint_value|
                 if constraint_value.present?
-                  route.constraints[constraint_name] && route.constraints[constraint_name].match?(constraint_value)
+                  route.constraints[constraint_name] && route.constraints[constraint_name].match(constraint_value)
                 else
                   route.constraints[constraint_name].blank?
                 end
@@ -152,14 +178,38 @@ module RoutesCoverage
             end
           end
         else
-          route.path.spec.to_s.match?(matcher)
+          route.path.spec.to_s.match(matcher)
         end
       end
 
-      [group_name, Result.new(group_routes, route_hit_count.slice(group_routes), settings)]
+      [group_name, Result.new(group_routes, route_hit_count.slice(*group_routes), settings)]
     end.to_h
   end
 
+  # NB: router changes env/request during recognition
+  def self._touch_request(req)
+    ::Rails.application.routes.router.recognize(req) do |route, parameters5, parameters4|
+      parameters = parameters5 || parameters4
+      dispatcher = route.app
+      if dispatcher.respond_to?(:dispatcher?)
+        req.path_parameters = parameters
+        dispatcher = nil unless dispatcher.matches?(req) # && dispatcher.dispatcher?
+      else # rails < 4.2
+        dispatcher = route.app
+        req.env['action_dispatch.request.path_parameters'] =
+          (req.env['action_dispatch.request.path_parameters'] || {}).merge(parameters)
+        while dispatcher.is_a?(ActionDispatch::Routing::Mapper::Constraints)
+          dispatcher = (dispatcher.app if dispatcher.matches?(req.env))
+        end
+      end
+      next unless dispatcher
+
+      RoutesCoverage._touch_route(route)
+      # there may be multiple matching routes - we should match only first
+      break
+    end
+  end
+
   def self._touch_route(route)
     reset! unless route_hit_count
     route_hit_count[route] += 1

data/routes_coverage.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency 'appraisal'
-  spec.add_development_dependency "bundler", ">= 2.2.10"
+  spec.add_development_dependency "bundler" #, ">= 2.2.10"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "rake", ">= 12.3.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: routes_coverage
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Vasily Fedoseyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-13 00:00:00.000000000 Z
+date: 2022-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: appraisal
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.10
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.10
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -74,6 +74,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - compiled_assets/routes.css
@@ -82,6 +83,7 @@ files:
 - lib/routes_coverage/adapters/atexit.rb
 - lib/routes_coverage/adapters/rspec.rb
 - lib/routes_coverage/adapters/simplecov.rb
+- lib/routes_coverage/auditor.rb
 - lib/routes_coverage/formatters/base.rb
 - lib/routes_coverage/formatters/full_text.rb
 - lib/routes_coverage/formatters/html.rb
@@ -111,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.9
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Provides coverage report for your rails routes