coverband 4.2.5.rc.2 → 5.0.0.rc.3

data/test/coverband/at_exit_test.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require File.expand_path('../test_helper', File.dirname(__FILE__))
+require File.expand_path("../test_helper", File.dirname(__FILE__))
 
 class AtExitTest < Minitest::Test
-  test 'only registers once' do
+  test "only registers once" do
     Coverband::AtExit.instance_eval { @at_exit_registered = nil }
     Coverband::AtExit.expects(:at_exit).yields.once.returns(true)
     2.times { Coverband::AtExit.register }

data/test/coverband/collectors/coverage_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require File.expand_path('../../test_helper', File.dirname(__FILE__))
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
 
 class CollectorsCoverageTest < Minitest::Test
   attr_accessor :coverband
@@ -19,111 +19,97 @@ class CollectorsCoverageTest < Minitest::Test
     @coverband = Coverband::Collectors::Coverage.instance.reset_instance
   end
 
-  test 'Dog class coverage' do
+  test "Dog class coverage" do
     file = require_unique_file
     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__))
+  test "Dog method and class coverage" do
+    load File.expand_path("../../dog.rb", File.dirname(__FILE__))
     Dog.new.bark
     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
+  test "Dog eager load coverage" do
     store = Coverband.configuration.store
     assert_equal Coverband::RUNTIME_TYPE, store.type
-    file = coverband.eager_loading do
+    file = coverband.eager_loading {
       require_unique_file
-    end
+    }
     coverage = Coverband.configuration.store.coverage[file]
-    assert_nil coverage, 'No runtime coverage'
+    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])
+    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
+  test "gets coverage instance" do
     assert_equal Coverband::Collectors::Coverage, coverband.class
   end
 
-  test 'defaults to a redis store' do
-    assert_equal Coverband::Adapters::RedisStore, coverband.instance_variable_get('@store').class
+  test "defaults to a redis store" do
+    assert_equal Coverband::Adapters::RedisStore, coverband.instance_variable_get("@store").class
   end
 
-  test 'report_coverage raises errors in tests' do
-    Coverband::Adapters::RedisStore.any_instance.stubs(:save_report).raises('Oh no')
+  test "report_coverage raises errors in tests" do
+    Coverband::Adapters::RedisStore.any_instance.stubs(:save_report).raises("Oh no")
     @coverband.reset_instance
     assert_raises RuntimeError do
       @coverband.report_coverage
     end
   end
 
-  test 'report_coverage raises errors in tests with verbose enabled' do
+  test "report_coverage raises errors in tests with verbose enabled" do
     Coverband.configuration.verbose = true
     logger = mock
     Coverband.configuration.logger = logger
     @coverband.reset_instance
-    Coverband::Adapters::RedisStore.any_instance.stubs(:save_report).raises('Oh no')
+    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
-    assert_match /Oh no/, error.message
-  end
-
-  test 'default tmp ignores' do
-    heroku_build_file = '/tmp/build_81feca8c72366e4edf020dc6f1937485/config/initializers/assets.rb'
-    assert_equal false, @coverband.send(:track_file?, heroku_build_file)
-  end
-
-  # verifies a fix where we were storing, merging, and tracking ignored files
-  # then just filtering them out of the final report
-  test 'ignores uses regex same as reporter does' do
-    regex_file = Coverband.configuration.current_root + '/config/initializers/fake.rb'
-    assert_equal true, @coverband.send(:track_file?, regex_file)
-    @coverband.instance_variable_set(:@ignore_patterns, ['config/initializers/*'])
-    assert_equal false, @coverband.send(:track_file?, regex_file)
+    assert_match %r{Oh no}, error.message
   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')
+  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)
+    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')
+  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)
+    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')
+  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)
+    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')
+  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)
+    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)

data/test/coverband/collectors/delta_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require File.expand_path('../../test_helper', File.dirname(__FILE__))
-require './lib/coverband/collectors/delta'
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
+require "./lib/coverband/collectors/delta"
 
 class CollectorsDeltaTest < Minitest::Test
   class MockSystemCoverage < Struct.new(:results)
@@ -13,83 +13,111 @@ class CollectorsDeltaTest < Minitest::Test
 
   def setup
     Coverband::Collectors::Delta.reset
+    Coverband::Collectors::Delta.class_variable_set(:@@project_directory, "car.rb")
   end
 
-  test 'No previous results' do
+  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)
   end
 
-  test 'Coverage has gone up' do
+  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
+  test "New file added to coverage" do
     current_coverage = {}
     results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
     assert_equal(current_coverage, results)
 
     current_coverage = {
-      'dealership.rb' => [nil, 1, 1, nil]
+      "dealership.rb" => [nil, 1, 1, nil]
     }
+    Coverband::Collectors::Delta.class_variable_set(:@@project_directory, "dealership.rb")
     results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
     assert_equal(current_coverage, results)
   end
 
-  test 'Coverage has branching enabled and has gone up' do
+  test "default tmp ignores" do
+    heroku_build_file = "/tmp/build_81feca8c72366e4edf020dc6f1937485/config/initializers/assets.rb"
+
+    current_coverage = {
+      heroku_build_file => [0, 5, 1]
+    }
+    Coverband::Collectors::Delta.class_variable_set(:@@project_directory, heroku_build_file)
+    results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
+    assert_equal({}, results)
+  end
+
+  # verifies a fix where we were storing, merging, and tracking ignored files
+  # then just filtering them out of the final report
+  test "ignores uses regex same as reporter does" do
+    regex_file = Coverband.configuration.current_root + "/config/initializers/fake.rb"
+
     current_coverage = {
-      'car.rb' => { lines: [nil, 1, 5, 1] }
+      regex_file => [0, 5, 1]
+    }
+
+    Coverband::Collectors::Delta.class_variable_set(:@@project_directory, regex_file)
+    Coverband::Collectors::Delta.class_variable_set(:@@ignore_patterns, ["config/initializers/*"])
+    results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
+    assert_equal({}, results)
+  end
+
+  test "Coverage has branching enabled and has gone up" do
+    current_coverage = {
+      "car.rb" => {lines: [nil, 1, 5, 1]}
     }
     ::Coverage.expects(:peek_result).returns(current_coverage)
-    results = Coverband::Collectors::Delta.results
+    Coverband::Collectors::Delta.results
 
     current_coverage = {
-      'car.rb' => { lines: [nil, 1, 7, 1] }
+      "car.rb" => {lines: [nil, 1, 7, 1]}
     }
     ::Coverage.expects(:peek_result).returns(current_coverage)
     results = Coverband::Collectors::Delta.results
-    assert_equal({ 'car.rb' => [nil, 0, 2, 0] }, results)
+    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
+    test "oneshot coverage calls clear" do
       Coverband.configuration.stubs(:use_oneshot_lines_coverage).returns(true)
       current_coverage = {
-        'car.rb' => [1, 5]
+        "car.rb" => [1, 5]
       }
 
       ::Coverage.expects(:result).with(clear: true, stop: false).returns(current_coverage)
-      results = Coverband::Collectors::Delta::RubyCoverage.results
+      Coverband::Collectors::Delta::RubyCoverage.results
     end
 
-    test 'one shot lines results' do
+    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]
+        "dealership.rb" => {
+          oneshot_lines: [2, 3]
         }
       }
-      ::Coverage.expects(:line_stub).with('dealership.rb').returns([nil, 0, 0, nil])
+      ::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]
+        "dealership.rb" => [nil, 1, 1, nil]
       }
       assert_equal(expected, results)
     end

data/test/coverband/collectors/view_tracker_test.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require File.expand_path('../../test_helper', File.dirname(__FILE__))
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
 
 class ReporterTest < Minitest::Test
   def tracker_key
-    'render_tracker_2'
+    "render_tracker_2"
   end
 
   def setup
@@ -12,102 +12,102 @@ class ReporterTest < Minitest::Test
     fake_store.raw_store.del(tracker_key)
   end
 
-  test 'init correctly' do
+  test "init correctly" do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
-    tracker = Coverband::Collectors::ViewTracker.new(store: fake_store, roots: 'dir')
-    assert_equal 'dir', tracker.roots.first
+    tracker = Coverband::Collectors::ViewTracker.new(store: fake_store, roots: "dir")
+    assert_equal "dir", tracker.roots.first
     assert !tracker.store.nil?
     assert_equal [], tracker.target
     assert_equal [], tracker.logged_views
   end
 
-  test 'track partials' do
+  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(:hset).with(tracker_key, file_path, anything)
-    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
-    tracker.track_views('name', 'start', 'finish', 'id', identifier: 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 partials that include the word vendor in the path' do
+  test "track partials that include the word vendor in the path" do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
     store = fake_store
     file_path = "#{File.expand_path(Coverband.configuration.root)}/vendor_relations/file"
-    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
-    tracker.track_views('name', 'start', 'finish', 'id', identifier: 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.used_views.keys
   end
 
-  test 'ignore partials that include the folder vendor in the path' do
+  test "ignore partials that include the folder vendor in the path" do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
     store = fake_store
     file_path = "#{File.expand_path(Coverband.configuration.root)}/vendor/file"
-    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
-    tracker.track_views('name', 'start', 'finish', 'id', identifier: 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 Hash.new, tracker.used_views
+    assert_equal({}, tracker.used_views)
   end
 
-  test 'track layouts' do
+  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(:hset).with(tracker_key, file_path, anything)
-    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
-    tracker.track_views('name', 'start', 'finish', 'id', layout: 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
+  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 = 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.keys
   end
 
-  test 'report unused partials' do
+  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)
+    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
+    assert_equal ["not_used"], tracker.unused_views
   end
 
-  test 'reset store' do
+  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('render_tracker_time')
-    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
-    tracker.track_views('name', 'start', 'finish', 'id', identifier: 'file')
+    store.raw_store.expects(:del).with("render_tracker_time")
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: "dir")
+    tracker.track_views("name", "start", "finish", "id", identifier: "file")
     tracker.reset_recordings
   end
 
-  test 'clear_file' do
+  test "clear_file" 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(:hdel).with(tracker_key, file_path)
-    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
-    tracker.track_views('name', 'start', 'finish', 'id', identifier: file_path)
-    tracker.clear_file!('file')
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: "dir")
+    tracker.track_views("name", "start", "finish", "id", identifier: file_path)
+    tracker.clear_file!("file")
     assert_equal [], tracker.logged_views
   end
 
   protected
 
   def fake_store
-    @fake_store ||= Coverband::Adapters::RedisStore.new(Coverband::Test.redis, redis_namespace: 'coverband_test')
+    @fake_store ||= Coverband::Adapters::RedisStore.new(Coverband::Test.redis, redis_namespace: "coverband_test")
   end
 end