coverband 4.2.0 → 4.2.1.rc1

data/test/coverband/reporters/web_test.rb

@@ -37,16 +37,6 @@ if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.2.0')
         post '/clear'
         assert_equal 301, last_response.status
       end
-
-      test 'collect_coverage' do
-        post '/collect_coverage'
-        assert_equal 301, last_response.status
-      end
-
-      test 'reload_files' do
-        post '/reload_files'
-        assert_equal 301, last_response.status
-      end
     end
   end
 end

data/test/coverband/utils/file_groups_test.rb

@@ -50,6 +50,6 @@ describe Coverband::Utils::FileGroups, :vendored_gems do
   end
 
   it 'does has gem files' do
-    assert_equal 'gem_name.rb', subject.grouped_results['Gems'].first.first.short_name
+    assert_equal '.gem_name.rb', subject.grouped_results['Gems'].first.first.short_name
   end
 end

data/test/coverband/utils/file_list_test.rb

@@ -9,7 +9,7 @@ require File.expand_path('../../test_helper', File.dirname(__FILE__))
 describe Coverband::Utils::FileList do
   subject do
     original_result = {
-      source_fixture('sample.rb') => [nil, 1, 1, 1, nil, nil, 1, 1, nil, nil],
+      source_fixture('sample.rb') => {'first_updated_at' => Time.at(0), 'data' => [nil, 1, 1, 1, nil, nil, 1, 1, nil, nil]},
       source_fixture('app/models/user.rb') => [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil],
       source_fixture('app/controllers/sample_controller.rb') => [nil, 2, 2, 0, nil, nil, 0, nil, nil, nil]
     }
@@ -44,11 +44,11 @@ describe Coverband::Utils::FileList do
     assert_equal [50.0, 80.0, 100.0], subject.covered_percentages
   end
 
-  it 'has the correct least covered file' do
-    assert subject.least_covered_file.match(/sample_controller.rb/)
-  end
-
   it 'has the correct covered strength' do
     assert_equal 0.9285714285714286, subject.covered_strength
   end
+
+  it 'has correct first_seen_at' do
+    assert_equal Time.at(0), subject.first_seen_at
+  end
 end

data/test/coverband/utils/html_formatter_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+class HTMLFormatterTest < Minitest::Test
+  def setup
+    super
+    @redis = Redis.new
+    @store = Coverband::Adapters::RedisStore.new(@redis, redis_namespace: 'coverband_test')
+    @store.clear!
+  end
+
+  test 'generate dynamic content hosted html report' do
+    Coverband.configure do |config|
+      config.store             = @store
+      config.s3_bucket         = nil
+      config.ignore            = ['notsomething.rb']
+    end
+    mock_file_hash
+    @store.send(:save_report, basic_coverage_full_path)
+
+    notice = nil
+    base_path = '/coverage'
+    filtered_report_files = Coverband::Reporters::Base.report(@store, {})
+    html = Coverband::Utils::HTMLFormatter.new(filtered_report_files,
+                                               base_path: base_path,
+                                               notice: notice).format_dynamic_html!
+    assert_match 'loading source data', html
+  end
+
+  test 'generate static HTML report file' do
+    Coverband.configure do |config|
+      config.store             = @store
+      config.s3_bucket         = nil
+      config.ignore            = ['notsomething.rb']
+    end
+    mock_file_hash
+    @store.send(:save_report, basic_coverage_full_path)
+
+    filtered_report_files = Coverband::Reporters::Base.report(@store, {})
+    Coverband::Utils::HTMLFormatter.new(filtered_report_files).format_static_html!
+    html = File.read("#{Coverband.configuration.root}/coverage/index.html")
+    assert_match 'Coverage first seen', html
+  end
+end

data/test/coverband/utils/result_test.rb

@@ -16,6 +16,27 @@ describe 'result' do
       }
     end
 
+    describe '#add_not_loaded_files' do
+      it 'Adds files not yet tracked' do
+        results = Coverband::Utils::Result.add_not_loaded_files({}, ['./test/dog.*'])
+        dog_file = results.keys.grep(/dog.rb/).first
+        assert dog_file
+      end
+
+      it 'Does not overrwrite existing coverage' do
+        dog_file = File.expand_path('./test/dog.rb')
+        results = Coverband::Utils::Result.add_not_loaded_files({ dog_file => [0, 1] }, ['./test/dog.*'])
+        assert_equal({ dog_file => [0, 1] }, results)
+      end
+
+      it 'Adds files not yet tracked from multiple file globs' do
+        dog_file = File.expand_path('./test/dog.rb')
+        test_helper_file = File.expand_path('./test/test_helper.rb')
+        results = Coverband::Utils::Result.add_not_loaded_files({}, ['./test/dog.*', './test/test_helper.rb'])
+        assert_equal [dog_file, test_helper_file].to_set, results.keys.to_set
+      end
+    end
+
     describe 'a simple cov result initialized from that' do
       subject { Coverband::Utils::Result.new(original_result) }
 
@@ -48,57 +69,16 @@ describe 'result' do
         assert_equal [80.0, 80.0, 100.0], subject.covered_percentages
       end
 
-      it 'has accurate least covered file' do
-        assert subject.least_covered_file.match(/sample_controller.rb/)
-      end
-
-      [:covered_percent,
-       :covered_percentages,
-       :least_covered_file,
-       :covered_strength,
-       :covered_lines,
-       :missed_lines,
-       :total_lines].each do |msg|
+      %i[covered_percent
+         covered_percentages
+         covered_strength
+         covered_lines
+         missed_lines
+         total_lines].each do |msg|
         it "responds to #{msg}" do
           assert(subject.respond_to?(msg))
         end
       end
-
-      describe 'dumped with to_hash' do
-        it 'is a hash' do
-          assert subject.to_hash.is_a?(Hash)
-        end
-
-        describe 'loaded back with from_hash' do
-          let(:dumped_result) do
-            Coverband::Utils::Result.from_hash(subject.to_hash)
-          end
-
-          it 'has 3 source files' do
-            assert_equal subject.source_files.count, dumped_result.source_files.count
-          end
-
-          it 'has the same covered_percent' do
-            assert_equal subject.covered_percent, dumped_result.covered_percent
-          end
-
-          it 'has the same covered_percentages' do
-            assert_equal subject.covered_percentages, dumped_result.covered_percentages
-          end
-
-          it 'has the same timestamp' do
-            assert_equal subject.created_at.to_i, dumped_result.created_at.to_i
-          end
-
-          it 'has the same command_name' do
-            assert_equal subject.command_name, dumped_result.command_name
-          end
-
-          it 'has the same original_result' do
-            assert_equal subject.original_result, dumped_result.original_result
-          end
-        end
-      end
     end
   end
 end

data/test/coverband/utils/results_test.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+describe 'results' do
+  describe 'with a (mocked) Coverage.result' do
+    let(:source_file) { Coverband::Utils::SourceFile.new(source_fixture('app/models/user.rb'), run_lines) }
+    let(:eager_lines) { [nil, 1, 1, 0, nil, nil, 1, 0, nil, nil] }
+    let(:run_lines) { [nil, nil, nil, 1, nil, nil, nil,nil, nil, nil] }
+    let(:original_result) do
+      orig = {
+        Coverband::MERGED_TYPE => {source_fixture('app/models/user.rb') => eager_lines},
+      }
+      orig.merge!({Coverband::EAGER_TYPE => {source_fixture('app/models/user.rb') => eager_lines}}) if eager_lines
+      orig.merge!({Coverband::RUNTIME_TYPE => {source_fixture('app/models/user.rb') => run_lines}}) if run_lines
+      orig
+    end
+    subject { Coverband::Utils::Results.new(original_result) }
+
+    describe 'runtime relevant lines is supported' do
+      it 'has correct runtime relevant coverage' do
+        assert_equal 50.0, subject.runtime_relevant_coverage(source_file)
+      end
+
+      it 'has correct runtime relevant lines' do
+        assert_equal 2, subject.runtime_relavent_lines(source_file)
+      end
+    end
+
+    describe 'runtime relevant lines when no runtime coverage exists' do
+      let(:run_lines) { nil }
+
+      it 'has correct runtime relevant lines' do
+        assert_equal 0.0, subject.runtime_relevant_coverage(source_file)
+      end
+
+      it 'has correct runtime relevant lines' do
+        assert_equal 2, subject.runtime_relavent_lines(source_file)
+      end
+    end
+
+    describe 'runtime relevant lines when no eager coverage exists' do
+      let(:eager_lines) { nil }
+
+      it 'has correct runtime relevant lines' do
+        assert_equal 100.0, subject.runtime_relevant_coverage(source_file)
+      end
+
+      it 'has correct runtime relevant lines' do
+        assert_equal 1, subject.runtime_relavent_lines(source_file)
+      end
+    end
+  end
+end

data/test/coverband/utils/s3_report_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../../test_helper', File.dirname(__FILE__))
 
 module Coverband

data/test/coverband/utils/source_file_test.rb

@@ -146,4 +146,54 @@ describe Coverband::Utils::SourceFile do
       assert_equal 0.0, subject.covered_percent
     end
   end
+
+  describe 'correctly identifies gems' do
+    COVERAGE_FOR_SKIPPED_AND_EXECUTED_RB = [nil, nil, 1, 1, 0, 1, 1, nil].freeze
+
+    describe 'the word gem in a path' do
+      subject do
+        Coverband::Utils::SourceFile.new('lib/rubocop/cop/gemspec/required_ruby_version.rb', COVERAGE_FOR_SKIPPED_AND_EXECUTED_RB)
+      end
+
+      it 'allows the word gem in path' do
+        assert_equal nil, subject.gem?
+      end
+    end
+
+    describe 'a folder gem in the path' do
+      subject do
+        Coverband::Utils::SourceFile.new('/var/gems/rubocop-0.67.0/lib/rubocop/cop/gemspec/required_ruby_version.rb', COVERAGE_FOR_SKIPPED_AND_EXECUTED_RB)
+      end
+
+      it 'allows the word gem in path' do
+        assert subject.gem?
+      end
+    end
+  end
+
+  describe 'correctly reports gem name' do
+    COVERAGE_FOR_SKIPPED_AND_EXECUTED_RB = [nil, nil, 1, 1, 0, 1, 1, nil].freeze
+
+    describe 'the word gem in a path' do
+      subject do
+        Coverband::Utils::SourceFile.new('lib/rubocop/cop/gemspec/required_ruby_version.rb', COVERAGE_FOR_SKIPPED_AND_EXECUTED_RB)
+      end
+
+      it 'allows the word gem in path' do
+        assert_equal nil, subject.gem_name
+      end
+    end
+
+    describe 'a folder gem in the path' do
+      subject do
+        Coverband::Utils::SourceFile.new('/var/gems/rubocop-0.67.0/lib/rubocop/cop/gemspec/required_ruby_version.rb', COVERAGE_FOR_SKIPPED_AND_EXECUTED_RB)
+      end
+
+      it 'allows the word gem in path' do
+        assert_equal 'rubocop-0.67.0', subject.gem_name
+      end
+    end
+  end
+
+
 end

data/test/forked/rails_full_stack_test.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require File.expand_path('../rails_test_helper', File.dirname(__FILE__))
+
+class RailsFullStackTest < Minitest::Test
+  include Capybara::DSL
+  include Capybara::Minitest::Assertions
+
+  def setup
+    super
+    rails_setup
+    # preload first coverage hit
+    Coverband.report_coverage
+  end
+
+  def teardown
+    super
+    Capybara.reset_sessions!
+    Capybara.use_default_driver
+  end
+
+  test 'list all gems even if no coverage' do
+    Capybara.current_driver = :selenium_chrome_headless
+    visit '/coverage'
+    find('a.Gems').click
+    assert_selector('a.gem-link', text: /pundit/)
+    assert_selector('a.gem-link', text: /rainbow/)
+  end
+
+  test 'this is how we do it' do
+    require 'rainbow'
+    Rainbow('this text is red').red
+    visit '/dummy/show'
+    Coverband.report_coverage
+    assert_content('I am no dummy')
+    visit '/coverage'
+    within page.find('a', text: /dummy_controller.rb/).find(:xpath, '../..') do
+      assert_selector('td', text: '100.0 %')
+    end
+
+    # Test gems are reporting coverage
+    assert_content('Gems')
+    assert page.html.match('rainbow/wrapper.rb')
+
+    # Test eager load data stored separately
+    dummy_controller = "./test/rails#{Rails::VERSION::MAJOR}_dummy/app/controllers/dummy_controller.rb"
+    store.type = :eager_loading
+    eager_expected = [1, 1, 0, nil, nil]
+    results = store.coverage[dummy_controller]['data']
+    assert_equal(eager_expected, results)
+
+    store.type = nil
+    runtime_expected = [0, 0, 1, nil, nil]
+    results = store.coverage[dummy_controller]['data']
+  end
+
+  ###
+  # Please keep this test starting on line 22
+  # as we run it in single test mode via the benchmarks.
+  # Add new tests below this test
+  ###
+  if ENV['COVERBAND_MEMORY_TEST']
+    test 'memory usage' do
+      return unless ENV['COVERBAND_MEMORY_TEST']
+
+      # we don't want this to run during our standard test suite
+      # as the below profiler changes the runtime
+      # and shold only be included for isolated processes
+      begin
+        require 'memory_profiler'
+
+        # warmup
+        3.times do
+          visit '/dummy/show'
+          assert_content('I am no dummy')
+          Coverband.report_coverage
+        end
+
+        previous_out = $stdout
+        capture = StringIO.new
+        $stdout = capture
+
+        MemoryProfiler.report do
+          15.times do
+            visit '/dummy/show'
+            assert_content('I am no dummy')
+            Coverband.report_coverage
+            # this is expected to retain memory across requests
+            # clear it to remove the false positive from test
+            Coverband::Collectors::Coverage.instance.send(:add_previous_results, nil)
+          end
+        end.pretty_print
+        data = $stdout.string
+        $stdout = previous_out
+        raise 'leaking memory!!!' if data.match(/retained objects by gem(.*)retained objects by file/m)[0]&.match(/coverband/)
+      ensure
+        $stdout = previous_out
+      end
+    end
+  end
+end

data/test/forked/rails_rake_full_stack_test.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../rails_test_helper', File.dirname(__FILE__))
+require 'rails'
+
+class RailsRakeFullStackTest < Minitest::Test
+
+  test 'rake tasks shows coverage properly within eager_loading' do
+    system("COVERBAND_CONFIG=./test/rails#{Rails::VERSION::MAJOR}_dummy/config/coverband.rb bundle exec rake -f test/rails#{Rails::VERSION::MAJOR}_dummy/Rakefile middleware")
+    store.instance_variable_set(:@redis_namespace, 'coverband_test')
+    store.type = :eager_loading
+    pundit_file = store.coverage.keys.grep(/pundit.rb/).first
+    refute_nil pundit_file
+    pundit_coverage = store.coverage[pundit_file]
+    refute_nil pundit_coverage
+    assert_includes pundit_coverage['data'], 1
+
+    store.type = nil
+    pundit_coverage = store.coverage[pundit_file]
+    assert_nil pundit_coverage
+  end
+
+  test "ignored rake tasks don't add coverage" do
+    store.instance_variable_set(:@redis_namespace, 'coverband_test')
+    store.send(:save_report, basic_coverage_full_path)
+    output = `COVERBAND_CONFIG=./test/rails#{Rails::VERSION::MAJOR}_dummy/config/coverband.rb bundle exec rake -f test/rails#{Rails::VERSION::MAJOR}_dummy/Rakefile coverband:clear`
+    assert_nil output.match(/Coverband: Reported coverage via thread/)
+    coverage_report = store.get_coverage_report
+    empty_hash = {}
+    assert_equal empty_hash, coverage_report[nil]
+    assert_equal empty_hash, coverage_report[:eager_loading]
+    assert_equal empty_hash, coverage_report[:merged]
+  end
+end

data/test/integration/full_stack_test.rb

@@ -6,52 +6,54 @@ require 'rack'
 class FullStackTest < Minitest::Test
   REDIS_STORAGE_FORMAT_VERSION = Coverband::Adapters::RedisStore::REDIS_STORAGE_FORMAT_VERSION
   TEST_RACK_APP = '../fake_app/basic_rack.rb'
-  RELATIVE_FILE = './fake_app/basic_rack.rb'
 
   def setup
     super
     Coverband::Collectors::Coverage.instance.reset_instance
     Coverband.configure do |config|
-      config.reporting_frequency = 100.0
-      config.store = Coverband::Adapters::RedisStore.new(Redis.new)
+      config.store = Coverband::Adapters::RedisStore.new(Redis.new(), redis_namespace: 'coverband_test')
       config.s3_bucket = nil
-      config.background_reporting_enabled = false
+      config.background_reporting_enabled = true
       config.root_paths = ["#{File.expand_path('../', File.dirname(__FILE__))}/"]
       config.track_gems = true
     end
     Coverband.configuration.store.clear!
     Coverband.start
+    Coverband::Collectors::Coverage.instance.eager_loading!
+    @rack_file = require_unique_file 'fake_app/basic_rack.rb'
+    Coverband.report_coverage
     Coverband::Collectors::Coverage.instance.runtime!
-    @rack_file = File.expand_path(TEST_RACK_APP, File.dirname(__FILE__))
-    require @rack_file
-    # preload first coverage hit
-    Coverband::Collectors::Coverage.instance.report_coverage(true)
   end
 
   test 'call app' do
     request = Rack::MockRequest.env_for('/anything.json')
-    middleware = Coverband::Middleware.new(fake_app_with_lines)
+    middleware = Coverband::BackgroundMiddleware.new(fake_app_with_lines)
     results = middleware.call(request)
     assert_equal 'Hello Rack!', results.last
-    sleep(0.2)
+    Coverband.report_coverage
     expected = [nil, nil, 0, nil, 0, 0, 1, nil, nil]
-    assert_equal expected, Coverband.configuration.store.coverage[RELATIVE_FILE]['data']
+    assert_equal expected, Coverband.configuration.store.coverage[@rack_file]['data']
 
     # additional calls increase count by 1
     middleware.call(request)
-    sleep(0.2)
+    Coverband.report_coverage
     expected = [nil, nil, 0, nil, 0, 0, 2, nil, nil]
-    assert_equal expected, Coverband.configuration.store.coverage[RELATIVE_FILE]['data']
+    assert_equal expected, Coverband.configuration.store.coverage[@rack_file]['data']
+
+    # class coverage
+    Coverband.eager_loading_coverage!
+    Coverband.configuration.store.coverage[@rack_file]['data']
+    expected = [nil, nil, 1, nil, 1, 1, 0, nil, nil]
   end
 
   test 'call app with gem tracking' do
     require 'rainbow'
     Rainbow('this text is red').red
     request = Rack::MockRequest.env_for('/anything.json')
-    middleware = Coverband::Middleware.new(fake_app_with_lines)
+    middleware = Coverband::BackgroundMiddleware.new(fake_app_with_lines)
     results = middleware.call(request)
     assert_equal 'Hello Rack!', results.last
-    sleep(0.1)
+    Coverband.report_coverage
     assert Coverband.configuration.store.coverage.keys.any? { |key| key.end_with?('rainbow/global.rb') }
   end