coverband 5.2.4 → 5.2.5.rc.2

data/lib/coverband/adapters/hash_redis_store.rb

@@ -119,7 +119,7 @@ module Coverband
 
         data = coverage_data_from_redis(data_from_redis)
         hash[file] = data_from_redis.select { |meta_data_key, _value| META_DATA_KEYS.include?(meta_data_key) }.merge!("data" => data)
-        hash[file][LAST_UPDATED_KEY] = hash[file][LAST_UPDATED_KEY].blank? ? nil : hash[file][LAST_UPDATED_KEY].to_i
+        hash[file][LAST_UPDATED_KEY] = hash[file][LAST_UPDATED_KEY].nil? || hash[file][LAST_UPDATED_KEY] == "" ? nil : hash[file][LAST_UPDATED_KEY].to_i
         hash[file].merge!(LAST_UPDATED_KEY => hash[file][LAST_UPDATED_KEY], FIRST_UPDATED_KEY => hash[file][FIRST_UPDATED_KEY].to_i)
       end
 

data/lib/coverband/adapters/redis_store.rb

@@ -31,8 +31,6 @@ module Coverband
         Coverband::TYPES.each do |type|
           @redis.del(type_base_key(type))
         end
-        # temporarily clear the old namespace of coverband_3_2
-        @redis.del(type_base_key(nil))
       end
 
       def clear_file!(filename)

data/lib/coverband/collectors/coverage.rb

@@ -99,7 +99,13 @@ module Coverband
           puts "Coverband: detected SimpleCov in test Env, allowing it to start Coverage"
           puts "Coverband: to ensure no error logs or missing Coverage call `SimpleCov.start` prior to requiring Coverband"
         else
-          if Coverage.ruby_version_greater_than_or_equal_to?("2.6.0")
+          if ::Coverage.respond_to?(:state)
+            if ::Coverage.state == :idle
+              ::Coverage.start(oneshot_lines: Coverband.configuration.use_oneshot_lines_coverage)
+            elsif ::Coverage.state == :suspended
+              ::Coverage.resume
+            end
+          elsif Coverage.ruby_version_greater_than_or_equal_to?("2.6.0")
             ::Coverage.start(oneshot_lines: Coverband.configuration.use_oneshot_lines_coverage) unless ::Coverage.running?
           elsif Coverage.ruby_version_greater_than_or_equal_to?("2.5.0")
             ::Coverage.start unless ::Coverage.running?

data/lib/coverband/collectors/route_tracker.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "set"
+require "singleton"
+
+module Coverband
+  module Collectors
+    ###
+    # This class tracks route usage via ActiveSupport::Notifications
+    ###
+    class RouteTracker
+      attr_accessor :target
+      attr_reader :logger, :store, :ignore_patterns
+
+      def initialize(options = {})
+        raise NotImplementedError, "Route Tracker requires Rails 4 or greater" unless self.class.supported_version?
+        raise "Coverband: route tracker initialized before configuration!" if !Coverband.configured? && ENV["COVERBAND_TEST"] == "test"
+
+        @ignore_patterns = Coverband.configuration.ignore
+        @store = options.fetch(:store) { Coverband.configuration.store }
+        @logger = options.fetch(:logger) { Coverband.configuration.logger }
+        @target = options.fetch(:target) do
+          if defined?(Rails.application)
+            Rails.application.routes.routes.map do |route|
+              {
+                controller: route.defaults[:controller],
+                action: route.defaults[:action],
+                url_path: route.path.spec.to_s.gsub("(.:format)", ""),
+                verb: route.verb
+              }.to_s
+            end
+          else
+            []
+          end
+        end
+
+        @one_time_timestamp = false
+
+        @logged_routes = Set.new
+        @routes_to_record = Set.new
+      end
+
+      def logged_routes
+        @logged_routes.to_a
+      end
+
+      def routes_to_record
+        @routes_to_record.to_a
+      end
+
+      ###
+      # This method is called on every routing call, so we try to reduce method calls
+      # and ensure high performance
+      ###
+      def track_routes(_name, _start, _finish, _id, payload)
+        route = if payload[:request]
+          {
+            controller: nil,
+            action: nil,
+            url_path: payload[:request].path,
+            verb: payload[:request].method
+          }
+        else
+          {
+            controller: payload[:controller],
+            action: payload[:action],
+            url_path: payload[:path],
+            verb: payload[:method]
+          }
+        end
+        if route
+          if newly_seen_route?(route)
+            @logged_routes << route
+            @routes_to_record << route if track_route?(route)
+          end
+        end
+      end
+
+      def used_routes
+        redis_store.hgetall(tracker_key)
+      end
+
+      def all_routes
+        all_routes = []
+        target.each do |route|
+          all_routes << route
+        end
+        all_routes.uniq
+      end
+
+      def unused_routes(used_routes = nil)
+        recently_used_routes = (used_routes || self.used_routes).keys
+        all_routes - recently_used_routes
+      end
+
+      def as_json
+        used_routes = self.used_routes
+        {
+          unused_routes: unused_routes(used_routes),
+          used_routes: used_routes
+        }.to_json
+      end
+
+      def tracking_since
+        if (tracking_time = redis_store.get(tracker_time_key))
+          Time.at(tracking_time.to_i).iso8601
+        else
+          "N/A"
+        end
+      end
+
+      def reset_recordings
+        redis_store.del(tracker_key)
+        redis_store.del(tracker_time_key)
+      end
+
+      def clear_route!(route)
+        return unless route
+
+        redis_store.hdel(tracker_key, route)
+        @logged_routes.delete(route)
+      end
+
+      def report_routes_tracked
+        redis_store.set(tracker_time_key, Time.now.to_i) unless @one_time_timestamp || tracker_time_key_exists?
+        @one_time_timestamp = true
+        reported_time = Time.now.to_i
+        @routes_to_record.to_a.each do |route|
+          redis_store.hset(tracker_key, route.to_s, reported_time)
+        end
+        @routes_to_record.clear
+      rescue => e
+        # we don't want to raise errors if Coverband can't reach redis.
+        # This is a nice to have not a bring the system down
+        logger&.error "Coverband: route_tracker failed to store, error #{e.class.name} info #{e.message}"
+      end
+
+      def self.supported_version?
+        defined?(Rails) && defined?(Rails::VERSION) && Rails::VERSION::STRING.split(".").first.to_i >= 4
+      end
+
+      protected
+
+      def newly_seen_route?(route)
+        !@logged_routes.include?(route)
+      end
+
+      def track_route?(route, options = {})
+        @ignore_patterns.none? { |pattern| route.to_s.include?(pattern) }
+      end
+
+      private
+
+      def redis_store
+        store.raw_store
+      end
+
+      def tracker_time_key_exists?
+        if defined?(redis_store.exists?)
+          redis_store.exists?(tracker_time_key)
+        else
+          redis_store.exists(tracker_time_key)
+        end
+      end
+
+      def tracker_key
+        "route_tracker_2"
+      end
+
+      def tracker_time_key
+        "route_tracker_time"
+      end
+    end
+  end
+end

data/lib/coverband/configuration.rb

@@ -8,7 +8,8 @@ module Coverband
       :background_reporting_enabled,
       :test_env, :web_enable_clear, :gem_details, :web_debug, :report_on_exit,
       :simulate_oneshot_lines_coverage,
-      :view_tracker, :defer_eager_loading_data
+      :view_tracker, :defer_eager_loading_data,
+      :track_routes, :route_tracker
     attr_writer :logger, :s3_region, :s3_bucket, :s3_access_key_id,
       :s3_secret_access_key, :password, :api_key, :service_url, :coverband_timeout, :service_dev_mode,
       :service_test_mode, :process_type, :track_views, :redis_url,
@@ -67,6 +68,8 @@ module Coverband
       @web_enable_clear = false
       @track_views = true
       @view_tracker = nil
+      @track_routes = false
+      @route_tracker = nil
       @web_debug = false
       @report_on_exit = true
       @use_oneshot_lines_coverage = ENV["ONESHOT"] || false

data/lib/coverband/integrations/background.rb

@@ -39,6 +39,7 @@ module Coverband
             sleep(sleep_seconds.to_i) if Coverband.configuration.defer_eager_loading_data?
             Coverband.report_coverage
             Coverband.configuration.view_tracker&.report_views_tracked
+            Coverband.configuration.route_tracker&.report_routes_tracked
             if Coverband.configuration.verbose
               logger.debug("Coverband: background reporting coverage (#{Coverband.configuration.store.type}). Sleeping #{sleep_seconds}s")
             end

data/lib/coverband/reporters/web.rb

@@ -38,6 +38,10 @@ module Coverband
         request_path_info = request.path_info == "" ? "/" : request.path_info
         if request.post?
           case request_path_info
+          when %r{\/clear_route_tracking_route}
+            clear_route_tracking_route
+          when %r{\/clear_route_tracking}
+            clear_route_tracking
           when %r{\/clear_view_tracking_file}
             clear_view_tracking_file
           when %r{\/clear_view_tracking}
@@ -59,6 +63,8 @@ module Coverband
             [200, {"Content-Type" => "text/json"}, [view_tracker_data]]
           when %r{\/view_tracker}
             [200, {"Content-Type" => "text/html"}, [view_tracker]]
+          when %r{\/route_tracker}
+            [200, {"Content-Type" => "text/html"}, [route_tracker]]
           when %r{\/enriched_debug_data}
             [200, {"Content-Type" => "text/json"}, [enriched_debug_data]]
           when %r{\/debug_data}
@@ -95,6 +101,14 @@ module Coverband
           base_path: base_path).format_view_tracker!
       end
 
+      def route_tracker
+        notice = "<strong>Notice:</strong> #{Rack::Utils.escape_html(request.params["notice"])}<br/>"
+        notice = request.params["notice"] ? notice : ""
+        Coverband::Utils::HTMLFormatter.new(nil,
+          notice: notice,
+          base_path: base_path).format_route_tracker!
+      end
+
       def view_tracker_data
         Coverband::Collectors::ViewTracker.new(store: Coverband.configuration.store).as_json
       end
@@ -126,7 +140,7 @@ module Coverband
         else
           notice = "web_enable_clear isn't enabled in your configuration"
         end
-        [301, {"Location" => "#{base_path}?notice=#{notice}"}, []]
+        [302, {"Location" => "#{base_path}?notice=#{notice}"}, []]
       end
 
       def clear_file
@@ -137,7 +151,7 @@ module Coverband
         else
           notice = "web_enable_clear isn't enabled in your configuration"
         end
-        [301, {"Location" => "#{base_path}?notice=#{notice}"}, []]
+        [302, {"Location" => "#{base_path}?notice=#{notice}"}, []]
       end
 
       def clear_view_tracking
@@ -148,7 +162,7 @@ module Coverband
         else
           notice = "web_enable_clear isn't enabled in your configuration"
         end
-        [301, {"Location" => "#{base_path}/view_tracker?notice=#{notice}"}, []]
+        [302, {"Location" => "#{base_path}/view_tracker?notice=#{notice}"}, []]
       end
 
       def clear_view_tracking_file
@@ -160,7 +174,30 @@ module Coverband
         else
           notice = "web_enable_clear isn't enabled in your configuration"
         end
-        [301, {"Location" => "#{base_path}/view_tracker?notice=#{notice}"}, []]
+        [302, {"Location" => "#{base_path}/view_tracker?notice=#{notice}"}, []]
+      end
+
+      def clear_route_tracking
+        if Coverband.configuration.web_enable_clear
+          tracker = Coverband::Collectors::RouteTracker.new(store: Coverband.configuration.store)
+          tracker.reset_recordings
+          notice = "route tracking reset"
+        else
+          notice = "web_enable_clear isn't enabled in your configuration"
+        end
+        [302, {"Location" => "#{base_path}/route_tracker?notice=#{notice}"}, []]
+      end
+
+      def clear_route_tracking_route
+        if Coverband.configuration.web_enable_clear
+          tracker = Coverband::Collectors::RouteTracker.new(store: Coverband.configuration.store)
+          route = request.params["route"]
+          tracker.clear_route!(route)
+          notice = "coverage for route #{route} cleared"
+        else
+          notice = "web_enable_clear isn't enabled in your configuration"
+        end
+        [302, {"Location" => "#{base_path}/route_tracker?notice=#{notice}"}, []]
       end
 
       private

data/lib/coverband/utils/html_formatter.rb

@@ -37,6 +37,10 @@ module Coverband
         format_view_tracker
       end
 
+      def format_route_tracker!
+        format_route_tracker
+      end
+
       def format_source_file!(filename)
         source_file = @coverage_result.file_from_path_with_type(filename)
 
@@ -57,6 +61,10 @@ module Coverband
         template("view_tracker").result(binding)
       end
 
+      def format_route_tracker
+        template("route_tracker").result(binding)
+      end
+
       def format(result)
         Dir[File.join(File.dirname(__FILE__), "../../../public/*")].each do |path|
           FileUtils.cp_r(path, asset_output_path)

data/lib/coverband/utils/rails6_ext.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+###
+# This backports routing redirect active notification events to Rails 6
+#
+# * reproducing this event: https://github.com/rails/rails/pull/43755/files
+#   * and pulls in the later: https://github.com/rails/rails/commit/40dc22f715ede12ab9b7e06d59fae185da2c38c7
+# * using alias method although prepend might be an interesting alternative
+# * this doesn't backport the built in listener for the event (ActionDispatch::LogSubscriber) as logging isn't needed
+###
+require "action_dispatch/routing/redirection"
+
+module ActionDispatch
+  module Routing
+    class Redirect < Endpoint
+      def call(env)
+        ActiveSupport::Notifications.instrument("redirect.action_dispatch") do |payload|
+          request = Request.new(env)
+          response = build_response(request)
+
+          payload[:status] = @status
+          payload[:location] = response.headers["Location"]
+          payload[:request] = request
+
+          response.to_a
+        end
+      end
+
+      def build_response(req)
+        uri = URI.parse(path(req.path_parameters, req))
+
+        unless uri.host
+          if relative_path?(uri.path)
+            uri.path = "#{req.script_name}/#{uri.path}"
+          elsif uri.path.empty?
+            uri.path = req.script_name.empty? ? "/" : req.script_name
+          end
+        end
+
+        uri.scheme ||= req.scheme
+        uri.host ||= req.host
+        uri.port ||= req.port unless req.standard_port?
+
+        req.commit_flash
+
+        body = ""
+
+        headers = {
+          "Location" => uri.to_s,
+          "Content-Type" => "text/html",
+          "Content-Length" => body.length.to_s
+        }
+
+        ActionDispatch::Response.new(status, headers, body)
+      end
+    end
+  end
+end

data/lib/coverband/utils/railtie.rb

@@ -28,6 +28,26 @@ module Coverband
       end
 
       begin
+        if Coverband.configuration.track_routes
+          if Gem::Version.new(Rails.version) >= Gem::Version.new("6.0.0") && Gem::Version.new(Rails.version) < Gem::Version.new("7.1.0")
+            require_relative "rails6_ext"
+          end
+
+          Coverband.configuration.route_tracker = Coverband::Collectors::RouteTracker.new
+
+          ActiveSupport::Notifications.subscribe("start_processing.action_controller") do |name, start, finish, id, payload|
+            Coverband.configuration.route_tracker.track_routes(name, start, finish, id, payload)
+          end
+
+          # NOTE: This event was instrumented in Aug 10th 2022, but didn't make the 7.0.4 release and should be in the next release
+          # https://github.com/rails/rails/pull/43755
+          # Automatic tracking of redirects isn't avaible before Rails 7.1.0 (currently tested against the 7.1.0.alpha)
+          # We could consider back porting or patching a solution that works on previous Rails versions
+          ActiveSupport::Notifications.subscribe("redirect.action_dispatch") do |name, start, finish, id, payload|
+            Coverband.configuration.route_tracker.track_routes(name, start, finish, id, payload)
+          end
+        end
+
         if Coverband.configuration.track_views
           COVERBAND_VIEW_TRACKER = if Coverband.coverband_service?
             Coverband::Collectors::ViewTrackerService.new

data/lib/coverband/version.rb

@@ -5,5 +5,5 @@
 # use format "4.2.1.rc.1" ~> 4.2.1.rc to prerelease versions like v4.2.1.rc.2 and v4.2.1.rc.3
 ###
 module Coverband
-  VERSION = "5.2.4"
+  VERSION = "5.2.5.rc.2"
 end

data/lib/coverband.rb

@@ -18,6 +18,7 @@ require "coverband/utils/file_hasher"
 require "coverband/collectors/coverage"
 require "coverband/collectors/view_tracker"
 require "coverband/collectors/view_tracker_service"
+require "coverband/collectors/route_tracker"
 require "coverband/reporters/base"
 require "coverband/reporters/console_report"
 require "coverband/integrations/background"

data/test/benchmarks/benchmark.rake

@@ -250,7 +250,6 @@ namespace :benchmarks do
 
   desc "checks memory of collector"
   task memory_check: [:setup] do
-    # require 'pry-byebug'
     require "objspace"
     puts "memory load check"
     puts(ObjectSpace.memsize_of_all / 2**20)

data/test/coverband/collectors/coverage_test.rb

@@ -77,8 +77,25 @@ class CollectorsCoverageTest < Minitest::Test
     assert_match %r{Oh no}, error.message
   end
 
+  test "using coverage state idle with ruby >= 3.1.0" do
+    return unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.1.0")
+
+    ::Coverage.expects(:state).returns(:idle)
+    ::Coverage.expects(:start).with(oneshot_lines: false)
+    Coverband::Collectors::Coverage.send(:new)
+  end
+
+  test "using coverage state suspended with ruby >= 3.1.0" do
+    return unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.1.0")
+
+    ::Coverage.expects(:state).returns(:suspended).at_least_once
+    ::Coverage.expects(:resume)
+    Coverband::Collectors::Coverage.send(:new)
+  end
+
   test "one shot line coverage disabled for ruby >= 2.6" do
     return unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.5.0")
+    ::Coverage.expects(:respond_to?).returns(false)
 
     Coverband::Collectors::Coverage.expects(:ruby_version_greater_than_or_equal_to?).with("2.6.0").returns(true)
     ::Coverage.expects(:running?).returns(false)
@@ -88,6 +105,7 @@ class CollectorsCoverageTest < Minitest::Test
 
   test "one shot line coverage enabled for ruby >= 2.6" do
     return unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.5.0")
+    ::Coverage.expects(:respond_to?).returns(false)
 
     Coverband.configuration.expects(:use_oneshot_lines_coverage).returns(true)
     Coverband::Collectors::Coverage.expects(:ruby_version_greater_than_or_equal_to?).with("2.6.0").returns(true)
@@ -98,6 +116,7 @@ class CollectorsCoverageTest < Minitest::Test
 
   test "one shot line coverage for ruby >= 2.6 when already running" do
     return unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.5.0")
+    ::Coverage.expects(:respond_to?).returns(false)
 
     Coverband::Collectors::Coverage.expects(:ruby_version_greater_than_or_equal_to?).with("2.6.0").returns(true)
     ::Coverage.expects(:running?).returns(true)
@@ -107,6 +126,7 @@ class CollectorsCoverageTest < Minitest::Test
 
   test "no one shot line coverage for ruby < 2.6" do
     return unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.5.0")
+    ::Coverage.expects(:respond_to?).returns(false)
 
     Coverband::Collectors::Coverage.expects(:ruby_version_greater_than_or_equal_to?).with("2.6.0").returns(false)
     Coverband::Collectors::Coverage.expects(:ruby_version_greater_than_or_equal_to?).with("2.5.0").returns(true)

data/test/coverband/collectors/route_tracker_test.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
+require "ostruct"
+
+class RouterTrackerTest < Minitest::Test
+  # NOTE: using struct vs open struct as open struct has a special keyword method that overshadows the method value on Ruby 2.x
+  Payload = Struct.new(:path, :method)
+
+  def tracker_key
+    Coverband::Collectors::RouteTracker.expects(:supported_version?).at_least_once.returns(true)
+    Coverband::Collectors::RouteTracker.new.send(:tracker_key)
+  end
+
+  def setup
+    super
+    fake_store.raw_store.del(tracker_key)
+  end
+
+  test "init correctly" do
+    Coverband::Collectors::RouteTracker.expects(:supported_version?).returns(true)
+    tracker = Coverband::Collectors::RouteTracker.new(store: fake_store, roots: "dir")
+    assert_equal nil, tracker.target.first
+    assert !tracker.store.nil?
+    assert_equal [], tracker.target
+    assert_equal [], tracker.logged_routes
+  end
+
+  test "track redirect routes" do
+    store = fake_store
+    route_hash = {controller: nil, action: nil, url_path: "path", verb: "GET"}
+    store.raw_store.expects(:hset).with(tracker_key, route_hash.to_s, anything)
+    tracker = Coverband::Collectors::RouteTracker.new(store: store, roots: "dir")
+
+    payload = {
+      request: Payload.new("path", "GET")
+    }
+    tracker.track_routes("name", "start", "finish", "id", payload)
+    tracker.report_routes_tracked
+    assert_equal [route_hash], tracker.logged_routes
+  end
+
+  test "track controller routes" do
+    store = fake_store
+    route_hash = {controller: "SomeController", action: "index", url_path: "path", verb: "GET"}
+    store.raw_store.expects(:hset).with(tracker_key, route_hash.to_s, anything)
+    tracker = Coverband::Collectors::RouteTracker.new(store: store, roots: "dir")
+    payload = {
+      controller: "SomeController",
+      action: "index",
+      path: "path",
+      method: "GET"
+    }
+    tracker.track_routes("name", "start", "finish", "id", payload)
+    tracker.report_routes_tracked
+    assert_equal [route_hash], tracker.logged_routes
+  end
+
+  test "report used routes" do
+    store = fake_store
+    route_hash = {controller: "SomeController", action: "index", url_path: "path", verb: "GET"}
+    tracker = Coverband::Collectors::RouteTracker.new(store: store, roots: "dir")
+    payload = {
+      controller: "SomeController",
+      action: "index",
+      path: "path",
+      method: "GET"
+    }
+    tracker.track_routes("name", "start", "finish", "id", payload)
+    tracker.report_routes_tracked
+    assert_equal [route_hash.to_s], tracker.used_routes.keys
+  end
+
+  test "report unused routes" do
+    store = fake_store
+    tracker = Coverband::Collectors::RouteTracker.new(store: store, roots: "dir")
+    payload = {
+      controller: "SomeController",
+      action: "index",
+      path: "path",
+      method: "GET"
+    }
+    tracker.track_routes("name", "start", "finish", "id", payload)
+    tracker.report_routes_tracked
+    assert_equal [], tracker.unused_routes
+  end
+
+  test "reset store" do
+    store = fake_store
+    payload = {
+      controller: "SomeController",
+      action: "index",
+      path: "path",
+      method: "GET"
+    }
+    store.raw_store.expects(:del).with(tracker_key)
+    store.raw_store.expects(:del).with("route_tracker_time")
+    tracker = Coverband::Collectors::RouteTracker.new(store: store, roots: "dir")
+    tracker.track_routes("name", "start", "finish", "id", payload)
+    tracker.reset_recordings
+  end
+
+  test "clear_file" do
+    store = fake_store
+    route_hash = {controller: "SomeController", action: "index", url_path: "path", verb: "GET"}
+    tracker = Coverband::Collectors::RouteTracker.new(store: store, roots: "dir")
+    payload = {
+      controller: "SomeController",
+      action: "index",
+      path: "path",
+      method: "GET"
+    }
+    tracker.track_routes("name", "start", "finish", "id", payload)
+    tracker.report_routes_tracked
+    assert_equal [route_hash.to_s], tracker.used_routes.keys
+    tracker.clear_route!(route_hash.to_s)
+    assert_equal [], tracker.store.raw_store.hgetall(tracker_key).keys
+  end
+
+  protected
+
+  def fake_store
+    @fake_store ||= Coverband::Adapters::RedisStore.new(Coverband::Test.redis, redis_namespace: "coverband_test")
+  end
+end

data/test/coverband/collectors/view_tracker_test.rb

@@ -2,7 +2,7 @@
 
 require File.expand_path("../../test_helper", File.dirname(__FILE__))
 
-class ReporterTest < Minitest::Test
+class ViewTrackerTest < Minitest::Test
   def tracker_key
     "render_tracker_2"
   end

data/test/coverband/reporters/web_test.rb

@@ -39,7 +39,7 @@ if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.2.0")
 
       test "clears coverband" do
         post "/clear"
-        assert_equal 301, last_response.status
+        assert_equal 302, last_response.status
       end
     end
   end

data/test/forked/rails_full_stack_views_test.rb

@@ -23,6 +23,7 @@ class RailsFullStackTest < Minitest::Test
     assert_content("I am no dummy view tracker text")
     Coverband.report_coverage
     Coverband.configuration.view_tracker&.report_views_tracked
+    Coverband.configuration.route_tracker&.report_routes_tracked
     visit "/coverage/view_tracker"
     assert_content("Used Views: (1)")
     assert_content("Unused Views: (2)")
@@ -30,6 +31,10 @@ class RailsFullStackTest < Minitest::Test
     assert_selector("li.unused-views", text: "dummy_view/show_haml.html.haml")
     assert_selector("li.unused-views", text: "dummy_view/show_slim.html.slim")
 
+    visit "/coverage/route_tracker"
+    assert_content("Used Routes: (1)")
+    assert_content("Unused Routes: (5)")
+
     visit "/dummy_view/show_haml"
     assert_content("I am haml text")
     Coverband.report_coverage