coverband 6.1.2.rc.1 → 6.1.3

data/lib/coverband/reporters/console_report.rb

@@ -7,11 +7,21 @@ module Coverband
     ###
     class ConsoleReport < Base
       def self.report(store, options = {})
-        scov_style_report = super(store, options)
-        scov_style_report[:merged].each_pair do |file, usage|
+        coverband_reports = Coverband::Reporters::Base.report(store, options)
+        fix_reports(coverband_reports)
+        result = Coverband::Utils::Results.new(coverband_reports)
+        source_files = result.source_files
+
+        Coverband.configuration.logger.info "total_files: #{source_files.length}"
+        Coverband.configuration.logger.info "lines_of_code: #{source_files.lines_of_code}"
+        Coverband.configuration.logger.info "lines_covered: #{source_files.covered_lines}"
+        Coverband.configuration.logger.info "lines_missed: #{source_files.missed_lines}"
+        Coverband.configuration.logger.info "covered_percent: #{source_files.covered_percent}"
+
+        coverband_reports[:merged].each_pair do |file, usage|
           Coverband.configuration.logger.info "#{file}: #{usage["data"]}"
         end
-        scov_style_report
+        coverband_reports
       end
     end
   end

data/lib/coverband/reporters/json_report.rb

@@ -5,13 +5,16 @@
 module Coverband
   module Reporters
     class JSONReport < Base
-      attr_accessor :filtered_report_files, :options, :page, :as_report, :store, :filename, :base_path
+      attr_accessor :filtered_report_files, :options, :page, :as_report, :store, :filename, :base_path, :line_coverage,
+        :for_merged_report
 
       def initialize(store, options = {})
         self.options = options
         self.page = options.fetch(:page) { nil }
         self.filename = options.fetch(:filename) { nil }
         self.as_report = options.fetch(:as_report) { false }
+        self.line_coverage = options.fetch(:line_coverage) { false }
+        self.for_merged_report = options.fetch(:for_merged_report) { false }
         self.base_path = options.fetch(:base_path) { "./" }
         self.store = store
 
@@ -28,6 +31,33 @@ module Coverband
         report_as_json
       end
 
+      def merge_reports(first_report, second_report, options = {})
+        merged_data = {}
+        merged_data[Coverband::RUNTIME_TYPE.to_s] = Coverband::Adapters::Base.new.send(
+          :merge_reports,
+          first_report[Coverband::RUNTIME_TYPE.to_s],
+          second_report[Coverband::RUNTIME_TYPE.to_s],
+          {skip_expansion: true}
+        )
+        if first_report[Coverband::EAGER_TYPE.to_s] && second_report[Coverband::EAGER_TYPE.to_s]
+          merged_data[Coverband::EAGER_TYPE.to_s] = Coverband::Adapters::Base.new.send(
+            :merge_reports,
+            first_report[Coverband::EAGER_TYPE.to_s],
+            second_report[Coverband::EAGER_TYPE.to_s],
+            {skip_expansion: true}
+          )
+        end
+        if first_report[Coverband::MERGED_TYPE.to_s] && second_report[Coverband::MERGED_TYPE.to_s]
+          merged_data[Coverband::MERGED_TYPE.to_s] = Coverband::Adapters::Base.new.send(
+            :merge_reports,
+            first_report[Coverband::MERGED_TYPE.to_s],
+            second_report[Coverband::MERGED_TYPE.to_s],
+            {skip_expansion: true}
+          )
+        end
+        merged_data
+      end
+
       private
 
       def coverage_css_class(covered_percent)
@@ -43,6 +73,8 @@ module Coverband
       end
 
       def report_as_json
+        return filtered_report_files.to_json if for_merged_report
+
         result = Coverband::Utils::Results.new(filtered_report_files)
         source_files = result.source_files
 
@@ -97,7 +129,7 @@ module Coverband
       def coverage_files(result, source_files)
         source_files.each_with_object({}) do |source_file, hash|
           runtime_coverage = result.file_with_type(source_file, Coverband::RUNTIME_TYPE)&.covered_lines_count || 0
-          hash[source_file.short_name] = {
+          data = {
             filename: source_file.filename,
             hash: Digest::SHA1.hexdigest(source_file.filename),
             never_loaded: source_file.never_loaded,
@@ -109,6 +141,8 @@ module Coverband
             covered_percent: source_file.covered_percent,
             covered_strength: source_file.covered_strength
           }
+          data[:coverage] = source_file.coverage if line_coverage
+          hash[source_file.short_name] = data
         end
       end
     end

data/lib/coverband/utils/dead_methods.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: ntrue
+# frozen_string_literal: true
 
 require "coverband/utils/method_definition_scanner"
 

data/lib/coverband/utils/html_formatter.rb

@@ -150,6 +150,14 @@ module Coverband
         end
       end
 
+      def missed_lines_css_class(count)
+        if count == 0
+          "green"
+        else
+          "red"
+        end
+      end
+
       # Return a (kind of) unique id for the source file given. Uses SHA1 on path for the id
       def id(source_file)
         Digest::SHA1.hexdigest(source_file.filename)
@@ -169,7 +177,16 @@ module Coverband
 
       def link_to_source_file(source_file)
         data_loader_url = "#{base_path}load_file_details?filename=#{source_file.filename}"
-        %(<a href="##{id source_file}" class="src_link" title="#{shortened_filename source_file}" data-loader-url="#{data_loader_url}" onclick="src_link_click(this)">#{shortened_filename source_file}</a>)
+        %(<a href="##{id source_file}" class="src_link" title="#{shortened_filename source_file}" data-loader-url="#{data_loader_url}" onclick="src_link_click(this)">#{truncate(shortened_filename(source_file))}</a>)
+      end
+
+      def truncate(text, length: 50)
+        if text.length <= length
+          text
+        else
+          omission = "..."
+          "#{text[0, length - omission.length]}#{omission}"
+        end
       end
     end
   end

data/lib/coverband/utils/results.rb

@@ -73,6 +73,19 @@ module Coverband
         get_results(type).respond_to?(method)
       end
 
+      # Note: small set of hacks for static html simplecov report (groups, created_at, & command_name)
+      def groups
+        @groups ||= {}
+      end
+
+      def created_at
+        @created_at ||= Time.now
+      end
+
+      def command_name
+        @command_name ||= "Coverband"
+      end
+
       private
 
       def get_eager_file(source_file)

data/lib/coverband/utils/source_file.rb

@@ -191,7 +191,9 @@ module Coverband
       end
 
       def lines_strength
-        lines.map(&:coverage).compact.reduce(:+)
+        lines.sum do |line|
+          line.coverage || 0
+        end
       end
 
       def relevant_lines
@@ -256,8 +258,7 @@ module Coverband
       # was at the start of the file name
       # I had previously patched this in my local Rails app
       def short_name
-        filename.sub(/^#{Coverband.configuration.root}/, ".")
-          .gsub(%r{^\.\/}, "")
+        filename.delete_prefix("#{Coverband.configuration.root}/")
       end
 
       def relative_path

data/lib/coverband/utils/tasks.rb

@@ -12,21 +12,100 @@ namespace :coverband do
     FileUtils.cp(config_template, "./config/coverband.rb")
   end
 
-  desc "report runtime Coverband code coverage"
+  desc "console formated report of Coverband code coverage"
   task :coverage do
+    require "coverband/utils/html_formatter"
+    require "coverband/utils/result"
+    require "coverband/utils/file_list"
+    require "coverband/utils/source_file"
+    require "coverband/utils/lines_classifier"
+    require "coverband/utils/results"
     Coverband::Reporters::ConsoleReport.report(Coverband.configuration.store)
   end
 
-  if defined?(RubyVM::AbstractSyntaxTree)
-    require "coverband/utils/dead_methods"
+  desc "JSON formated report of Coverband code coverage"
+  task :coverage_json do
+    require "coverband/utils/html_formatter"
+    require "coverband/utils/result"
+    require "coverband/utils/file_list"
+    require "coverband/utils/source_file"
+    require "coverband/utils/lines_classifier"
+    require "coverband/utils/results"
+    require "coverband/reporters/json_report"
 
-    desc "Output all dead methods"
-    task :dead_methods do
-      Coverband::Utils::DeadMethods.output_all
+    report = Coverband::Reporters::JSONReport.new(Coverband.configuration.store, {
+      for_merged_report: !!ENV["FOR_MERGED_REPORT"],
+      line_coverage: true
+    }).report
+    `mkdir -p coverage`
+    File.write("coverage/coverage.json.#{Time.now.to_f}", report)
+  end
+
+  ###
+  # The Coverband UI now requires the dynamic rack server, however
+  # Coverband can still generate a SimpleCov compatible JSON report
+  # for use with the SimpleCov HTML formatter.
+  #
+  # To use this your project Gemfile must include simplecov and simplecov-html
+  # gem "simplecov", require: false
+  # gem "simplecov-html", require: false
+  # the file is written to coverage/index.html
+  ###
+  desc "static HTML formated report of Coverband code coverage"
+  task :coverage_html do
+    require "coverband/utils/html_formatter"
+    require "coverband/utils/result"
+    require "coverband/utils/file_list"
+    require "coverband/utils/source_file"
+    require "coverband/utils/lines_classifier"
+    require "coverband/utils/results"
+
+    require "simplecov"
+    require "simplecov-html"
+    `mkdir -p coverage`
+    # For a fully static HTML that can be copied to artifacts are part of CI
+    # we generate with inline assets
+    ENV["SIMPLECOV_INLINE_ASSETS"] = "true"
+    coverband_reports = Coverband::Reporters::Base.report(Coverband.configuration.store)
+    Coverband::Reporters::Base.fix_reports(coverband_reports)
+    result = Coverband::Utils::Results.new(coverband_reports)
+    SimpleCov::Formatter::HTMLFormatter.new.format(result)
+  end
+
+  ####
+  # This task can aggregate multiple coverage files into a single coverage report
+  # * `FOR_MERGED_REPORT=true bundle exec rake coverband:coverage_json` to generate the JSON files
+  # * collect all the files over time in some system or as artifacts in CI, then run...
+  # * `bundle exec rake coverband:aggregate_coverage` to merge the files
+  # * the output will include a timestamp of when it was output...
+  ####
+  task :aggregate_coverage do |task, args|
+    require "coverband/utils/result"
+    require "coverband/utils/file_list"
+    require "coverband/utils/source_file"
+    require "coverband/utils/lines_classifier"
+    require "coverband/utils/results"
+    require "coverband/reporters/json_report"
+
+    directory = "./coverage"
+    pattern = "coverage.json*"
+
+    # Use Dir.glob to find files matching the pattern in the specified directory
+    files = Dir.glob(File.join(directory, pattern))
+
+    report = {}
+    files.each do |file|
+      data = JSON.parse(File.read(file))
+      report = if report.empty?
+        data
+      else
+        Coverband::Reporters::JSONReport.new(Coverband.configuration.store).merge_reports(report, data)
+      end
     end
+    File.write("coverage/coverage_merged.json.#{Time.now.to_f}", report.to_json)
   end
 
-  desc "report runtime Coverband code coverage"
+  desc "Run a simple rack app to report Coverband code coverage"
   task :coverage_server do
     if Rake::Task.task_defined?("environment")
       Rake.application["environment"].invoke
@@ -38,6 +117,17 @@ namespace :coverband do
       Port: ENV.fetch("COVERBAND_COVERAGE_PORT", 9022).to_i
   end
 
+  # experimental dead method detection using RubyVM::AbstractSyntaxTree
+  # combined with the coverband coverage.
+  if defined?(RubyVM::AbstractSyntaxTree)
+    require "coverband/utils/dead_methods"
+
+    desc "Output all dead methods"
+    task :dead_methods do
+      Coverband::Utils::DeadMethods.output_all
+    end
+  end
+
   ###
   # clear data helpful for development or after configuration issues
   ###
@@ -54,12 +144,4 @@ namespace :coverband do
     trackers = Coverband.configuration.trackers
     trackers.each(&:reset_recordings)
   end
-
-  ###
-  # Updates the data in the coverband store from one format to another
-  ###
-  desc "upgrade previous Coverband datastore to latest format"
-  task :migrate do
-    Coverband.configuration.store.migrate!
-  end
 end

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 = "6.1.2.rc.1"
+  VERSION = "6.1.3"
 end

data/lib/coverband.rb

@@ -14,6 +14,7 @@ require "coverband/adapters/hash_redis_store"
 require "coverband/adapters/file_store"
 require "coverband/adapters/stdout_store"
 require "coverband/adapters/null_store"
+require "coverband/adapters/memcached_store"
 require "coverband/utils/file_hasher"
 require "coverband/collectors/coverage"
 require "coverband/collectors/abstract_tracker"
@@ -51,7 +52,7 @@ module Coverband
     elsif File.exist?(configuration_file)
       load configuration_file
     else
-      configuration.logger.debug("using default configuration")
+      configuration.logger.debug("using default configuration") if Coverband.configuration.verbose
     end
     @@configured = true
     coverage_instance.reset_instance
@@ -116,6 +117,7 @@ module Coverband
         start
       end
       require "coverband/integrations/resque" if defined? ::Resque
+      require "coverband/integrations/sidekiq_swarm" if defined? ::Sidekiq::Enterprise::Swarm
     rescue Redis::CannotConnectError => error
       Coverband.configuration.logger.info "Redis is not available (#{error}), Coverband not configured"
       Coverband.configuration.logger.info "If this is a setup task like assets:precompile feel free to ignore"

data/test/benchmarks/benchmark.rake

@@ -61,7 +61,6 @@ namespace :benchmarks do
       config.logger = $stdout
       config.store = benchmark_redis_store
       config.use_oneshot_lines_coverage = true if ENV["ONESHOT"]
-      config.simulate_oneshot_lines_coverage = true if ENV["SIMULATE_ONESHOT"]
     end
   end
 

data/test/coverband/adapters/base_test.rb

@@ -4,7 +4,7 @@ require File.expand_path("../../test_helper", File.dirname(__FILE__))
 
 class AdaptersBaseTest < Minitest::Test
   def test_abstract_methods
-    abstract_methods = %w[clear! clear_file! migrate! size save_coverage coverage]
+    abstract_methods = %w[clear! clear_file! size save_coverage coverage]
     abstract_methods.each do |method|
       assert_raises RuntimeError do
         Coverband::Adapters::Base.new.send(method.to_sym)
@@ -26,9 +26,6 @@ class AdaptersBaseTest < Minitest::Test
     assert_equal [8, 11, nil, nil], Coverband::Adapters::Base.new.send(:array_add, latest, original)
     Coverband.configuration.stubs(:use_oneshot_lines_coverage).returns(true)
     assert_equal [1, 1, nil, nil], Coverband::Adapters::Base.new.send(:array_add, latest, original)
-    Coverband.configuration.stubs(:use_oneshot_lines_coverage).returns(false)
-    Coverband.configuration.stubs(:simulate_oneshot_lines_coverage).returns(true)
-    assert_equal [1, 1, nil, nil], Coverband::Adapters::Base.new.send(:array_add, latest, original)
   end
 
   describe "Coverband::Adapters::Base using file" do

data/test/coverband/adapters/hash_redis_store_test.rb

@@ -192,57 +192,6 @@ class HashRedisStoreTest < Minitest::Test
     assert_nil @store.get_coverage_report[:merged]["./dog.rb"]
   end
 
-  def test_get_coverage_cache
-    @store = Coverband::Adapters::HashRedisStore.new(
-      @redis,
-      redis_namespace: "coverband_test",
-      relative_file_converter: MockRelativeFileConverter,
-      get_coverage_cache: true
-    )
-    @store.get_coverage_cache.stubs(:deferred_time).returns(0)
-    @store.get_coverage_cache.clear!
-    mock_file_hash
-    yesterday = DateTime.now.prev_day.to_time
-    mock_time(yesterday)
-    @store.save_report(
-      "app_path/dog.rb" => [0, 1, 2]
-    )
-    assert_equal(
-      {
-        "first_updated_at" => yesterday.to_i,
-        "last_updated_at" => yesterday.to_i,
-        "file_hash" => "abcd",
-        "data" => [0, 1, 2],
-        "timedata" => [nil, Time.at(yesterday.to_i), Time.at(yesterday.to_i)]
-      },
-      @store.coverage["./dog.rb"]
-    )
-    @store.save_report(
-      "app_path/dog.rb" => [0, 1, 2]
-    )
-    assert_equal(
-      {
-        "first_updated_at" => yesterday.to_i,
-        "last_updated_at" => yesterday.to_i,
-        "file_hash" => "abcd",
-        "data" => [0, 1, 2],
-        "timedata" => [nil, Time.at(yesterday.to_i), Time.at(yesterday.to_i)]
-      },
-      @store.coverage["./dog.rb"]
-    )
-    sleep 0.1 # wait caching thread finish
-    assert_equal(
-      {
-        "first_updated_at" => yesterday.to_i,
-        "last_updated_at" => yesterday.to_i,
-        "file_hash" => "abcd",
-        "data" => [0, 2, 4],
-        "timedata" => [nil, Time.at(yesterday.to_i), Time.at(yesterday.to_i)]
-      },
-      @store.coverage["./dog.rb"]
-    )
-  end
-
   def test_split_coverage
     @store = Coverband::Adapters::HashRedisStore.new(
       @redis,

data/test/coverband/adapters/memecached_store_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
+
+if ENV["COVERBAND_MEMCACHED"]
+  require "active_support"
+  require "dalli"
+
+  class MemcachedTest < Minitest::Test
+    def setup
+      super
+      @store = Coverband::Adapters::MemcachedStore.new(ActiveSupport::Cache::MemCacheStore.new)
+    end
+
+    def test_coverage
+      @store.clear!
+      mock_file_hash
+      expected = basic_coverage
+      @store.save_report(expected)
+      assert_equal expected.keys, @store.coverage.keys
+      @store.coverage.each_pair do |key, data|
+        assert_equal expected[key], data["data"]
+      end
+    end
+  end
+end

data/test/coverband/adapters/redis_store_test.rb

@@ -79,14 +79,6 @@ unless ENV["COVERBAND_HASH_REDIS_STORE"]
       assert_equal example_line, @store.coverage["app_path/dog.rb"]["data"]
     end
 
-    def test_coverage_with_simulate_oneshot_lines_coverage
-      Coverband.configuration.stubs(:simulate_oneshot_lines_coverage).returns(true)
-      mock_file_hash
-      expected = basic_coverage
-      @store.save_report(expected)
-      assert_equal example_line, @store.get_coverage_report[:runtime]["app_path/dog.rb"]["data"]
-    end
-
     def test_coverage_when_null
       assert_nil @store.coverage["app_path/dog.rb"]
     end

data/test/coverband/collectors/coverage_test.rb

@@ -92,46 +92,4 @@ class CollectorsCoverageTest < Minitest::Test
     ::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)
-    ::Coverage.expects(:start).with(oneshot_lines: false)
-    Coverband::Collectors::Coverage.send(:new)
-  end
-
-  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)
-    ::Coverage.expects(:running?).returns(false)
-    ::Coverage.expects(:start).with(oneshot_lines: true)
-    Coverband::Collectors::Coverage.send(:new)
-  end
-
-  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)
-    ::Coverage.expects(:start).never
-    Coverband::Collectors::Coverage.send(:new)
-  end
-
-  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)
-    ::Coverage.expects(:running?).returns(false)
-    ::Coverage.expects(:start).with
-    Coverband::Collectors::Coverage.send(:new)
-  end
 end

data/test/coverband/collectors/delta_test.rb

@@ -92,35 +92,33 @@ class CollectorsDeltaTest < Minitest::Test
     assert_equal({"car.rb" => [nil, 0, 2, 0]}, results)
   end
 
-  if Coverband.configuration.one_shot_coverage_implemented_in_ruby_version?
-    test "oneshot coverage calls clear" do
-      Coverband.configuration.stubs(:use_oneshot_lines_coverage).returns(true)
-      current_coverage = {
-        "car.rb" => [1, 5]
-      }
+  test "oneshot coverage calls clear" do
+    Coverband.configuration.stubs(:use_oneshot_lines_coverage).returns(true)
+    current_coverage = {
+      "car.rb" => [1, 5]
+    }
 
-      ::Coverage.expects(:result).with(clear: true, stop: false).returns(current_coverage)
-      Coverband::Collectors::Delta::RubyCoverage.results
-    end
+    ::Coverage.expects(:result).with(clear: true, stop: false).returns(current_coverage)
+    Coverband::Collectors::Delta::RubyCoverage.results
+  end
 
-    test "one shot lines results" do
-      Coverband.configuration.stubs(:use_oneshot_lines_coverage).returns(true)
-      current_coverage = {}
-      results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
-      assert_equal(current_coverage, results)
+  test "one shot lines results" do
+    Coverband.configuration.stubs(:use_oneshot_lines_coverage).returns(true)
+    current_coverage = {}
+    results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
+    assert_equal(current_coverage, results)
 
-      current_coverage = {
-        "dealership.rb" => {
-          oneshot_lines: [2, 3]
-        }
-      }
-      Coverband::Collectors::Delta.class_variable_set(:@@project_directory, "dealership.rb")
-      ::Coverage.expects(:line_stub).with("dealership.rb").returns([nil, 0, 0, nil])
-      results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
-      expected = {
-        "dealership.rb" => [nil, 1, 1, nil]
+    current_coverage = {
+      "dealership.rb" => {
+        oneshot_lines: [2, 3]
       }
-      assert_equal(expected, results)
-    end
+    }
+    Coverband::Collectors::Delta.class_variable_set(:@@project_directory, "dealership.rb")
+    ::Coverage.expects(:line_stub).with("dealership.rb").returns([nil, 0, 0, nil])
+    results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
+    expected = {
+      "dealership.rb" => [nil, 1, 1, nil]
+    }
+    assert_equal(expected, results)
   end
 end

data/test/coverband/collectors/route_tracker_test.rb

@@ -174,7 +174,7 @@ class RouterTrackerTest < Minitest::Test
       method: "GET"
     }
     store.raw_store.expects(:del).with(tracker_key)
-    store.raw_store.expects(:del).with("RouteTracker_tracker_time")
+    store.raw_store.expects(:del).with("#{tracker_key}_time")
     tracker = Coverband::Collectors::RouteTracker.new(store: store, roots: "dir")
     tracker.track_key(payload)
     tracker.reset_recordings

data/test/coverband/collectors/view_tracker_test.rb

@@ -4,11 +4,12 @@ require File.expand_path("../../test_helper", File.dirname(__FILE__))
 
 class ViewTrackerTest < Minitest::Test
   def tracker_key
-    "ViewTracker_tracker"
+    "coverband_test_ViewTracker_tracker"
   end
 
   def setup
     super
+    Coverband.configuration.ignore += ["app/views/anything/ignore_me.html.erb"]
     fake_store.raw_store.del(tracker_key)
   end
 
@@ -94,11 +95,23 @@ class ViewTrackerTest < Minitest::Test
     assert_equal ["not_used"], tracker.unused_keys
   end
 
+  test "report hides partials marked in ignore config" do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = fake_store
+    file_path = "#{File.expand_path(Coverband.configuration.root)}/app/views/anything/ignore_me.html.erb"
+    target = [file_path, "not_used"]
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: "dir", target: target)
+    tracker.track_key(identifier: file_path)
+    tracker.save_report
+    assert_equal ["not_used"], tracker.unused_keys
+    assert_equal [], tracker.used_keys.keys
+  end
+
   test "reset store" do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
     store = fake_store
     store.raw_store.expects(:del).with(tracker_key)
-    store.raw_store.expects(:del).with("ViewTracker_tracker_time")
+    store.raw_store.expects(:del).with("#{tracker_key}_time")
     tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: "dir")
     tracker.track_key(identifier: "file")
     tracker.reset_recordings