coverband 4.2.0 → 4.2.2

data/test/coverband/adapters/hash_redis_store_test.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+class HashRedisStoreTest < Minitest::Test
+  REDIS_STORAGE_FORMAT_VERSION = Coverband::Adapters::HashRedisStore::REDIS_STORAGE_FORMAT_VERSION
+
+  class MockRelativeFileConverter
+    def self.convert(file)
+      file.sub('app_path/', './')
+    end
+  end
+
+  def setup
+    super
+    @redis = Redis.new
+    # FIXME: remove dependency on configuration and instead pass this in as an argument
+    Coverband.configure do |config|
+      config.root_paths = ['app_path/']
+    end
+    @store = Coverband::Adapters::HashRedisStore.new(@redis, redis_namespace: 'coverband_test', relative_file_converter: MockRelativeFileConverter)
+    @store.clear!
+    Coverband.configuration.store = @store
+  end
+
+  def mock_time(time = Time.now)
+    Time.stubs(:now).returns(time)
+    time
+  end
+
+  def test_no_coverage
+    @store.save_report({})
+    assert_equal({}, @store.coverage)
+  end
+
+  class UnsupportedRedis
+    def info
+      { 'redis_version' => '2.5.0' }
+    end
+  end
+
+  def test_unsupported_redis
+    assert_raises RuntimeError do
+      Coverband::Adapters::HashRedisStore.new(UnsupportedRedis.new)
+    end
+  end
+
+  def test_coverage_for_file
+    yesterday = DateTime.now.prev_day.to_time
+    today = Time.now
+    mock_time(yesterday)
+    mock_file_hash
+    @store.save_report(
+      'app_path/dog.rb' => [0, 1, 2]
+    )
+    assert_equal(
+      {
+        'first_updated_at' => yesterday.to_i,
+        'last_updated_at' => yesterday.to_i,
+        'data' => [0, 1, 2]
+      },
+      @store.coverage['./dog.rb']
+    )
+    mock_time(today)
+    @store.save_report(
+      'app_path/dog.rb' => [1, 1, 0]
+    )
+    assert_equal(
+      {
+        'first_updated_at' => yesterday.to_i,
+        'last_updated_at' => today.to_i,
+        'data' => [1, 2, 2]
+      },
+      @store.coverage['./dog.rb']
+    )
+  end
+
+  def test_ttl_set
+    mock_file_hash(hash: 'abcd')
+    @store = Coverband::Adapters::HashRedisStore.new(@redis, redis_namespace: 'coverband_test', ttl: 3600, relative_file_converter: MockRelativeFileConverter)
+    @store.save_report(
+      'app_path/dog.rb' => [0, 1, 2]
+    )
+    assert_operator(@redis.ttl("#{REDIS_STORAGE_FORMAT_VERSION}.coverband_test.runtime../dog.rb.abcd"), :>, 0)
+  end
+
+  def test_no_ttl_set
+    mock_file_hash(hash: 'abcd')
+    @store = Coverband::Adapters::HashRedisStore.new(@redis, redis_namespace: 'coverband_test', ttl: nil, relative_file_converter: MockRelativeFileConverter)
+    @store.save_report(
+      'app_path/dog.rb' => [0, 1, 2]
+    )
+    assert_equal(-1, @redis.ttl("#{REDIS_STORAGE_FORMAT_VERSION}.coverband_test.runtime../dog.rb.abcd"))
+  end
+
+  def test_coverage_for_multiple_files
+    current_time = mock_time
+    mock_file_hash
+    data = {
+      'app_path/dog.rb' => [0, nil, 1, 2],
+      'app_path/cat.rb' => [1, 2, 0, 1, 5],
+      'app_path/ferrit.rb' => [1, 5, nil, 2, nil]
+    }
+    @store.save_report(data)
+    coverage = @store.coverage
+    assert_equal(
+      {
+        'first_updated_at' => current_time.to_i,
+        'last_updated_at' => current_time.to_i,
+        'data' => [0, nil, 1, 2]
+      }, @store.coverage['./dog.rb']
+    )
+    assert_equal [1, 2, 0, 1, 5], @store.coverage['./cat.rb']['data']
+    assert_equal [1, 5, nil, 2, nil], @store.coverage['./ferrit.rb']['data']
+  end
+
+  def test_file_hash_change
+    mock_file_hash(hash: 'abc')
+    @store.save_report('app_path/dog.rb' => [0, nil, 1, 2])
+    coverage = @store.coverage
+    assert_equal [0, nil, 1, 2], @store.coverage['./dog.rb']['data']
+    @store.instance_eval { @file_hash_cache = {} }
+    mock_file_hash(hash: '123')
+    $debug = true
+    assert_nil @store.coverage['./dog.rb']
+  end
+
+  def test_type
+    mock_file_hash
+    @store.type = :eager_loading
+    data = {
+      'app_path/dog.rb' => [0, nil, 1, 2]
+    }
+    @store.save_report(data)
+    assert_equal 1, @store.coverage.length
+    assert_equal [0, nil, 1, 2], @store.coverage['./dog.rb']['data']
+    @store.type = Coverband::RUNTIME_TYPE
+    data = {
+      'app_path/cat.rb' => [1, 2, 0, 1, 5]
+    }
+    @store.save_report(data)
+    assert_equal 1, @store.coverage.length
+    assert_equal [1, 2, 0, 1, 5], @store.coverage['./cat.rb']['data']
+  end
+
+  def test_coverage_type
+    mock_file_hash
+    @store.type = :eager_loading
+    data = {
+      'app_path/dog.rb' => [0, nil, 1, 2]
+    }
+    @store.save_report(data)
+    @store.type = Coverband::RUNTIME_TYPE
+    assert_equal [0, nil, 1, 2], @store.coverage(:eager_loading)['./dog.rb']['data']
+  end
+
+  def test_clear
+    mock_file_hash
+    @store.type = Coverband::EAGER_TYPE
+    data = {
+      'app_path/dog.rb' => [0, nil, 1, 2]
+    }
+    @store.save_report(data)
+    assert_equal 1, @store.coverage.length
+    @store.type = Coverband::RUNTIME_TYPE
+    data = {
+      'app_path/cat.rb' => [1, 2, 0, 1, 5]
+    }
+    @store.save_report(data)
+    assert_equal 1, @store.coverage.length
+    @redis.set('random', 'data')
+    @store.clear!
+    @store.type = Coverband::RUNTIME_TYPE
+    assert @store.coverage.empty?
+    @store.type = :eager_loading
+    assert @store.coverage.empty?
+    assert_equal 'data', @redis.get('random')
+  end
+
+  def test_clear_file
+    mock_file_hash
+    @store.type = :eager_loading
+    @store.save_report('app_path/dog.rb' => [0, 1, 1])
+    @store.type = Coverband::RUNTIME_TYPE
+    @store.save_report('app_path/dog.rb' => [1, 0, 1])
+    assert_equal [1, 1, 2], @store.get_coverage_report[:merged]['./dog.rb']['data']
+    @store.clear_file!('app_path/dog.rb')
+    assert_nil @store.get_coverage_report[:merged]['./dog.rb']
+  end
+end

data/test/coverband/adapters/redis_store_test.rb

@@ -2,77 +2,110 @@
 
 require File.expand_path('../../test_helper', File.dirname(__FILE__))
 
-class RedisTest < Minitest::Test
-  REDIS_STORAGE_FORMAT_VERSION = Coverband::Adapters::RedisStore::REDIS_STORAGE_FORMAT_VERSION
+unless ENV['COVERBAND_HASH_REDIS_STORE']
+  class RedisTest < Minitest::Test
+    REDIS_STORAGE_FORMAT_VERSION = Coverband::Adapters::RedisStore::REDIS_STORAGE_FORMAT_VERSION
 
-  def setup
-    super
-    @redis = Redis.new
-    @store = Coverband::Adapters::RedisStore.new(@redis)
-  end
+    def setup
+      super
+      Coverband.configuration.redis_namespace = 'coverband_test'
+      @redis = Redis.new
+      @store = Coverband::Adapters::RedisStore.new(@redis, redis_namespace: 'coverband_test')
+      Coverband.configuration.store = @store
+      @store.clear!
+    end
 
-  def test_coverage
-    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']
+    def test_coverage
+      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
 
-  def test_coverage_increments
-    mock_file_hash
-    expected = basic_coverage.dup
-    @store.save_report(basic_coverage.dup)
-    assert_equal expected.keys, @store.coverage.keys
-    @store.coverage.each_pair do |key, data|
-      assert_equal expected[key], data['data']
+    def test_coverage_increments
+      mock_file_hash
+      expected = basic_coverage.dup
+      @store.save_report(basic_coverage.dup)
+      assert_equal expected.keys, @store.coverage.keys
+      @store.coverage.each_pair do |key, data|
+        assert_equal expected[key], data['data']
+      end
+      @store.save_report(basic_coverage.dup)
+      assert_equal [0, 2, 4], @store.coverage['app_path/dog.rb']['data']
     end
-    @store.save_report(basic_coverage.dup)
-    assert_equal [0, 2, 4], @store.coverage['app_path/dog.rb']['data']
-  end
 
-  def test_store_coverage_by_type
-    mock_file_hash
-    expected = basic_coverage
-    @store.type = :eager_loading
-    @store.save_report(expected)
-    assert_equal expected.keys, @store.coverage.keys
-    @store.coverage.each_pair do |key, data|
-      assert_equal expected[key], data['data']
+    def test_store_coverage_by_type
+      mock_file_hash
+      expected = basic_coverage
+      @store.type = :eager_loading
+      @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
+
+      @store.type = Coverband::RUNTIME_TYPE
+      assert_equal [], @store.coverage.keys
     end
 
-    @store.type = nil
-    assert_equal [], @store.coverage.keys
-  end
+    def test_merged_coverage_with_types
+      mock_file_hash
+      assert_equal Coverband::RUNTIME_TYPE, @store.type
+      @store.type = :eager_loading
+      @store.save_report('app_path/dog.rb' => [0, 1, 1])
+      @store.type = Coverband::RUNTIME_TYPE
+      @store.save_report('app_path/dog.rb' => [1, 0, 1])
+      assert_equal [1, 1, 2], @store.get_coverage_report[:merged]['app_path/dog.rb']['data']
+      assert_equal Coverband::RUNTIME_TYPE, @store.type
+    end
 
-  def test_merged_coverage_with_types
-    mock_file_hash
-    assert_nil @store.type
-    @store.type = :eager_loading
-    @store.save_report('app_path/dog.rb' => [0, 1, 1])
-    @store.type = nil
-    @store.save_report('app_path/dog.rb' => [1, 0, 1])
-    assert_equal [1, 1, 2], @store.get_coverage_report[:merged]['app_path/dog.rb']['data']
-    assert_nil @store.type
-  end
+    def test_coverage_for_file
+      mock_file_hash
+      expected = basic_coverage
+      @store.save_report(expected)
+      assert_equal example_line, @store.coverage['app_path/dog.rb']['data']
+    end
 
-  def test_covered_lines_for_file
-    mock_file_hash
-    expected = basic_coverage
-    @store.save_report(expected)
-    assert_equal example_line, @store.covered_lines_for_file('app_path/dog.rb')
-  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_covered_lines_when_null
-    assert_equal [], @store.covered_lines_for_file('app_path/dog.rb')
-  end
+    def test_coverage_when_null
+      assert_nil @store.coverage['app_path/dog.rb']
+    end
 
-  def test_clear
-    @redis.expects(:del).twice
-    @store.clear!
-  end
+    def test_clear
+      @redis.expects(:del).times(3)
+      @store.clear!
+    end
 
+    def test_clear_file
+      mock_file_hash
+      @store.type = :eager_loading
+      @store.save_report('app_path/dog.rb' => [0, 1, 1])
+      @store.type = Coverband::RUNTIME_TYPE
+      @store.save_report('app_path/dog.rb' => [1, 0, 1])
+      assert_equal [1, 1, 2], @store.get_coverage_report[:merged]['app_path/dog.rb']['data']
+      @store.clear_file!('app_path/dog.rb')
+      assert_nil @store.get_coverage_report[:merged]['app_path/dog.rb']
+    end
+
+    def test_size
+      mock_file_hash
+      @store.type = :eager_loading
+      @store.save_report('app_path/dog.rb' => [0, 1, 1])
+      assert @store.size > 1
+    end
 
+    def test_base_key
+      assert @store.send(:base_key).end_with?(Coverband::RUNTIME_TYPE.to_s)
+    end
+  end
 end

data/test/coverband/at_exit_test.rb

@@ -9,5 +9,3 @@ class AtExitTest < Minitest::Test
     2.times { Coverband::AtExit.register }
   end
 end
-
-

data/test/coverband/collectors/coverage_test.rb

@@ -8,11 +8,11 @@ class CollectorsCoverageTest < Minitest::Test
   def setup
     super
     Coverband.configure do |config|
-      config.store = Coverband::Adapters::RedisStore.new(Redis.new)
+      config.store = Coverband::Adapters::RedisStore.new(Redis.new, redis_namespace: 'coverband_test')
     end
     @coverband = Coverband::Collectors::Coverage.instance.reset_instance
     # preload first coverage hit
-    @coverband.report_coverage(true)
+    @coverband.report_coverage
   end
 
   def teardown
@@ -24,17 +24,31 @@ class CollectorsCoverageTest < Minitest::Test
 
   test 'Dog class coverage' do
     file = require_unique_file
-    coverband.report_coverage(true)
+    coverband.report_coverage
     coverage = Coverband.configuration.store.coverage
-    assert_equal(coverage[file]["data"], [nil, nil, 1, 1, 0, nil, nil])
+    assert_equal(coverage[file]['data'], [nil, nil, 1, 1, 0, nil, nil])
   end
 
   test 'Dog method and class coverage' do
     load File.expand_path('../../dog.rb', File.dirname(__FILE__))
     Dog.new.bark
-    coverband.report_coverage(true)
+    coverband.report_coverage
     coverage = Coverband.configuration.store.coverage
-    assert_equal(coverage["./test/dog.rb"]["data"], [nil, nil, 1, 1, 1, nil, nil])
+    assert_equal(coverage['./test/dog.rb']['data'], [nil, nil, 1, 1, 1, nil, nil])
+  end
+
+  test 'Dog eager load coverage' do
+    store = Coverband.configuration.store
+    assert_equal Coverband::RUNTIME_TYPE, store.type
+    file = coverband.eager_loading do
+      require_unique_file
+    end
+    coverage = Coverband.configuration.store.coverage[file]
+    assert_nil coverage, 'No runtime coverage'
+    coverband.eager_loading!
+    coverage = Coverband.configuration.store.coverage[file]
+    refute_nil coverage, 'Eager load coverage is present'
+    assert_equal(coverage['data'], [nil, nil, 1, 1, 0, nil, nil])
   end
 
   test 'gets coverage instance' do
@@ -46,8 +60,8 @@ class CollectorsCoverageTest < Minitest::Test
   end
 
   test 'report_coverage raises errors in tests' do
+    Coverband::Adapters::RedisStore.any_instance.stubs(:save_report).raises('Oh no')
     @coverband.reset_instance
-    @coverband.expects(:ready_to_report?).raises('Oh no')
     assert_raises RuntimeError do
       @coverband.report_coverage
     end
@@ -55,11 +69,11 @@ class CollectorsCoverageTest < Minitest::Test
 
   test 'report_coverage raises errors in tests with verbose enabled' do
     Coverband.configuration.verbose = true
-    logger = mock()
+    logger = mock
     Coverband.configuration.logger = logger
     @coverband.reset_instance
-    @coverband.expects(:ready_to_report?).raises('Oh no')
-    logger.expects(:error).times(3)
+    Coverband::Adapters::RedisStore.any_instance.stubs(:save_report).raises('Oh no')
+    logger.expects(:error).at_least(3)
     error = assert_raises RuntimeError do
       @coverband.report_coverage
     end
@@ -70,4 +84,42 @@ class CollectorsCoverageTest < Minitest::Test
     heroku_build_file = '/tmp/build_81feca8c72366e4edf020dc6f1937485/config/initializers/assets.rb'
     assert_equal false, @coverband.send(:track_file?, heroku_build_file)
   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')
+
+    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')
+
+    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')
+
+    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')
+
+    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

@@ -17,7 +17,7 @@ class CollectorsDeltaTest < Minitest::Test
 
   test 'No previous results' do
     current_coverage = {
-      'car.rb' => [0,5,1]
+      'car.rb' => [0, 5, 1]
     }
     results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
     assert_equal(current_coverage, results)
@@ -25,16 +25,16 @@ class CollectorsDeltaTest < Minitest::Test
 
   test 'Coverage has gone up' do
     current_coverage = {
-      'car.rb' => [nil,1,5,1]
+      'car.rb' => [nil, 1, 5, 1]
     }
     results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
     assert_equal(current_coverage, results)
 
     current_coverage = {
-      'car.rb' => [nil,1,7,1]
+      'car.rb' => [nil, 1, 7, 1]
     }
     results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
-    assert_equal({'car.rb' => [nil, 0, 2, 0]}, results)
+    assert_equal({ 'car.rb' => [nil, 0, 2, 0] }, results)
   end
 
   test 'New file added to coverage' do
@@ -43,10 +43,40 @@ class CollectorsDeltaTest < Minitest::Test
     assert_equal(current_coverage, results)
 
     current_coverage = {
-      'dealership.rb' => [nil,1,1,nil]
+      'dealership.rb' => [nil, 1, 1, nil]
     }
     results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
     assert_equal(current_coverage, results)
   end
-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]
+      }
+
+      ::Coverage.expects(:result).with(clear: true, stop: false).returns(current_coverage)
+      results = 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)
+
+      current_coverage = {
+        'dealership.rb' => {
+          :oneshot_lines => [2,3]
+        }
+      }
+      ::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
+end

data/test/coverband/collectors/view_tracker_test.rb

@@ -0,0 +1,77 @@
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+class ReporterTest < Minitest::Test
+
+  def setup
+    super
+    fake_store.raw_store.del('render_tracker')
+  end
+
+  test "init correctly" do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    tracker = Coverband::Collectors::ViewTracker.new(:store => "store", :roots => 'dir')
+    assert_equal 'dir', tracker.roots.first
+    assert_equal 'store', tracker.store
+    assert_equal [], tracker.target
+    assert_equal [], tracker.logged_views
+  end
+
+  test "track partials" do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = fake_store
+    file_path = "#{File.expand_path(Coverband.configuration.root)}/file"
+    store.raw_store.expects(:sadd).with('render_tracker', file_path)
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
+    tracker.track_views('name', 'start', 'finish', 'id', {:identifier => file_path})
+    tracker.report_views_tracked
+    assert_equal [file_path], tracker.logged_views
+  end
+
+  test "track layouts" do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = fake_store
+    file_path = "#{File.expand_path(Coverband.configuration.root)}/layout"
+    store.raw_store.expects(:sadd).with('render_tracker', file_path)
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
+    tracker.track_views('name', 'start', 'finish', 'id', {:layout => file_path})
+    tracker.report_views_tracked
+    assert_equal [file_path], tracker.logged_views
+  end
+
+  test "report used partials" do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = fake_store
+    file_path = "#{File.expand_path(Coverband.configuration.root)}/file"
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
+    tracker.track_views('name', 'start', 'finish', 'id', {:identifier => file_path})
+    tracker.report_views_tracked
+    assert_equal [file_path], tracker.used_views
+  end
+
+  test "report unused partials" do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = fake_store
+    file_path = "#{File.expand_path(Coverband.configuration.root)}/file"
+    target = [file_path, 'not_used']
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir', target: target)
+    tracker.track_views('name', 'start', 'finish', 'id', {:identifier => file_path})
+    tracker.report_views_tracked
+    assert_equal ['not_used'], tracker.unused_views
+  end
+
+  test "reset store" do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = fake_store
+    store.raw_store.expects(:del).with('render_tracker')
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
+    tracker.track_views('name', 'start', 'finish', 'id', {:identifier => 'file'})
+    tracker.reset_recordings
+  end
+
+  protected
+
+  def fake_store
+    @fake_store ||= Coverband::Adapters::RedisStore.new(Redis.new, redis_namespace: 'coverband_test')
+  end
+
+end