coverband 4.2.0 → 4.2.4

data/test/coverband/utils/source_file_test.rb

@@ -62,6 +62,10 @@ describe Coverband::Utils::SourceFile do
     it 'has 80% covered_percent' do
       assert_equal 80.0, subject.covered_percent
     end
+
+    it 'working for nil last_updated_at' do
+      assert_equal "not available", subject.last_updated_at
+    end
   end
 
   describe 'simulating potential Ruby 1.9 defect -- see Issue #56' do
@@ -146,4 +150,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/dog.rb.erb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Dog<%=dog_number%>
+
+  def self.bark
+    new.bark
+  end
+
+  def bark
+    'woof'
+  end
+end

data/test/forked/rails_full_stack_test.rb

@@ -0,0 +1,106 @@
+# 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
+    require 'rainbow'
+    Rainbow('this text is red').red
+  end
+
+  def teardown
+    super
+    Capybara.reset_sessions!
+    Capybara.use_default_driver
+  end
+
+  # We have to combine everything in one test
+  # because we can only initialize rails once per test
+  # run. Possibly fork test runs to avoid this problem in future?
+  unless ENV['COVERBAND_MEMORY_TEST']
+    test 'this is how we do it' do
+      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 = Coverband::RUNTIME_TYPE
+      runtime_expected = [0, 0, 1, nil, nil]
+      results = store.coverage[dummy_controller]['data']
+    end
+  end
+
+  ###
+  # 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
+            ###
+            # Set to nil not {} as it is easier to verify that no memory is retained when nil gets released
+            # don't use Coverband::Collectors::Delta.reset which sets to {}
+            #
+            # we clear this as this one variable is expected to retain memory and is a false positive
+            ###
+            Coverband::Collectors::Delta.class_variable_set(:@@previous_coverage, nil)
+            # needed to test older versions to discover when we had the regression
+            # Coverband::Collectors::Coverage.instance.send(:add_previous_results, nil)
+          end
+        end.pretty_print
+        data = $stdout.string
+        $stdout = previous_out
+        if data.match(/retained objects by gem(.*)retained objects by file/m)[0]&.match(/coverband/)
+          puts data
+          raise 'leaking memory!!!'
+        end
+      ensure
+        $stdout = previous_out
+      end
+    end
+  end
+end

data/test/forked/rails_rake_full_stack_test.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require File.expand_path('../rails_test_helper', File.dirname(__FILE__))
+require 'rails'
+require 'pundit'
+
+class RailsRakeFullStackTest < Minitest::Test
+  def setup
+    super
+    Coverband.configuration.reset
+    Coverband.configure("./test/rails#{Rails::VERSION::MAJOR}_dummy/config/coverband.rb")
+  end
+
+  test 'rake tasks shows coverage properly within eager_loading' do
+    store.instance_variable_set(:@redis_namespace, 'coverband_test')
+    store.clear!
+    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 = Coverband::RUNTIME_TYPE
+    if ENV['SIMULATE_ONESHOT']
+      pundit_coverage = store.get_coverage_report[Coverband::RUNTIME_TYPE][pundit_file]
+      assert pundit_coverage['data'].compact.all? { |el| el == 0 }
+    else
+      pundit_coverage = store.coverage[pundit_file]
+      assert_nil pundit_coverage
+    end
+  end
+
+  test "ignored rake tasks don't add coverage" do
+    store.clear!
+    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[Coverband::RUNTIME_TYPE]
+    assert_equal empty_hash, coverage_report[:eager_loading]
+    assert_equal empty_hash, coverage_report[:merged]
+  end
+
+  test "doesn't exit non-zero with error on missing redis" do
+    output = `COVERBAND_CONFIG=./test/rails#{Rails::VERSION::MAJOR}_dummy/config/coverband_missing_redis.rb bundle exec rake -f test/rails#{Rails::VERSION::MAJOR}_dummy/Rakefile -T`
+    assert_equal 0, $?.to_i
+    if ENV['COVERBAND_HASH_REDIS_STORE']
+      assert output.match(/Redis is not available/)
+    else
+      assert output.match(/coverage failed to store/)
+    end
+  end
+end

data/test/integration/full_stack_test.rb

@@ -6,52 +6,51 @@ 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.s3_bucket = nil
       config.background_reporting_enabled = false
-      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
 

data/test/rails4_dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative 'config/application'
+
+Rails.application.load_tasks

data/test/rails4_dummy/config/application.rb

@@ -1,15 +1,14 @@
-require File.expand_path('../boot', __FILE__)
+# frozen_string_literal: true
+
+require File.expand_path('boot', __dir__)
+
+require 'rails'
+require 'action_controller/railtie'
+require 'coverband'
+Bundler.require(*Rails.groups)
 
-require "rails"
-require "action_controller/railtie"
 module Rails4Dummy
   class Application < Rails::Application
-    # Coverband needs to be setup before any of the initializers to capture usage of them
-    Coverband.configure(File.open("#{Rails.root}/config/coverband.rb"))
-    config.middleware.use Coverband::Middleware
-    config.before_initialize do
-      Coverband.start
-    end
     config.eager_load = true
   end
 end

data/test/rails4_dummy/config/coverband.rb

@@ -1,11 +1,3 @@
-Coverband.configure do |config|
-  config.root              = Dir.pwd
-  config.store             = Coverband::Adapters::RedisStore.new(Redis.new(url: ENV['REDIS_URL'])) if defined? Redis
-  config.ignore            = %w[vendor .erb$ .slim$]
-  config.root_paths        = []
-  config.logger              = Rails.logger
-  config.verbose           = true
-  config.background_reporting_enabled = false
-  config.track_gems = true
-  config.gem_details = true
-end
+# frozen_string_literal: true
+
+require_relative '../../rails5_dummy/config/coverband'

data/test/rails4_dummy/config/coverband_missing_redis.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative '../../rails5_dummy/config/coverband_missing_redis'

data/test/rails5_dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative 'config/application'
+
+Rails.application.load_tasks

data/test/rails5_dummy/config/application.rb

@@ -1,16 +1,12 @@
-require "rails"
-require "action_controller/railtie"
+# frozen_string_literal: true
+
+require 'rails'
+require 'action_controller/railtie'
 require 'coverband'
+Bundler.require(*Rails.groups)
 
-module Dummy
+module Rails5Dummy
   class Application < Rails::Application
-    # Coverband needs to be setup before any of the initializers to capture usage of them
-    Coverband.configure(File.open("#{Rails.root}/config/coverband.rb"))
-    config.middleware.use Coverband::Middleware
-    config.before_initialize do
-      Coverband.start
-    end
     config.eager_load = true
   end
 end
-

data/test/rails5_dummy/config/coverband.rb

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
+
 Coverband.configure do |config|
   config.root              = Dir.pwd
-  config.store             = Coverband::Adapters::RedisStore.new(Redis.new(url: ENV['REDIS_URL'])) if defined? Redis
-  config.ignore            = %w[vendor .erb$ .slim$]
+  config.store             = Coverband::Adapters::RedisStore.new(Redis.new(db: 2, url: ENV['REDIS_URL']), redis_namespace: 'coverband_test') if defined? Redis
+  config.ignore            = %w[.erb$ .slim$]
   config.root_paths        = []
   config.logger            = Rails.logger
   config.verbose           = true
-  config.background_reporting_enabled = false
+  config.background_reporting_enabled = true
   config.track_gems = true
   config.gem_details = true
+  config.use_oneshot_lines_coverage = true if ENV['ONESHOT']
+  config.simulate_oneshot_lines_coverage = true if ENV['SIMULATE_ONESHOT']
 end

data/test/rails5_dummy/config/coverband_missing_redis.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+Coverband.configure do |config|
+  config.root              = Dir.pwd
+  config.store             = Coverband::Adapters::RedisStore.new(Redis.new(db: 2, url: 'redis://127.0.0.1:123'), redis_namespace: 'coverband_test') if defined? Redis
+  config.ignore            = %w[vendor .erb$ .slim$]
+  config.root_paths        = []
+  config.logger            = Rails.logger
+  config.verbose           = true
+  config.background_reporting_enabled = true
+  config.track_gems = true
+  config.gem_details = true
+  config.use_oneshot_lines_coverage = true if ENV['ONESHOT']
+  config.simulate_oneshot_lines_coverage = true if ENV['SIMULATE_ONESHOT']
+end

data/test/rails_test_helper.rb

@@ -1,16 +1,33 @@
+# frozen_string_literal: true
+
+require 'minitest'
+require 'minitest/fork_executor'
+
+# Forked executor includes autorun which does not work with qrush/m
+# https://github.com/qrush/m/issues/26
+# https://github.com/seattlerb/minitest/blob/master/lib/minitest/autorun.rb
+if defined?(M)
+  Minitest.class_eval do
+    def self.autorun
+      puts 'No autorunning'
+    end
+  end
+end
+
+Minitest.parallel_executor = Minitest::ForkExecutor.new
 require File.expand_path('./test_helper', File.dirname(__FILE__))
 require 'capybara'
 require 'capybara/minitest'
 def rails_setup
-  ENV["RAILS_ENV"] = "test"
+  ENV['RAILS_ENV'] = 'test'
   require 'rails'
-  #coverband must be required after rails
-  load 'coverband/utils/railtie.rb'
+  # coverband must be required after rails
   Coverband.configure("./test/rails#{Rails::VERSION::MAJOR}_dummy/config/coverband.rb")
+  load 'coverband/utils/railtie.rb'
+
   require_relative "../test/rails#{Rails::VERSION::MAJOR}_dummy/config/environment"
   require 'capybara/rails'
-  #Our coverage report is wrapped in display:none as of now
+  # Our coverage report is wrapped in display:none as of now
   Capybara.ignore_hidden_elements = false
   require 'mocha/minitest'
 end
-

data/test/test_helper.rb

@@ -7,8 +7,8 @@ original_verbosity = $VERBOSE
 $VERBOSE = nil
 require 'rubygems'
 require 'aws-sdk-s3'
-require 'coveralls'
 require 'simplecov'
+require 'coveralls'
 require 'minitest/autorun'
 require 'mocha/minitest'
 require 'ostruct'
@@ -19,18 +19,35 @@ require 'pry-byebug'
 require_relative 'unique_files'
 $VERBOSE = original_verbosity
 
-Coveralls.wear!
+unless ENV['ONESHOT'] || ENV['SIMULATE_ONESHOT']
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  SimpleCov.start do
+    add_filter 'test/forked'
+  end
+
+  Coveralls.wear!
+end
 
 module Coverband
   module Test
+    TEST_DB = 2
+
+    def self.redis
+      @redis ||= Redis.new(db: TEST_DB)
+    end
+
     def self.reset
-      [:eager_loading, nil].each do |type|
-        Coverband.configuration.store.type = type
-        Coverband.configuration.store.clear!
-      end
+      Coverband.configuration.redis_namespace = 'coverband_test'
+      Coverband.configuration.store.instance_variable_set(:@redis_namespace, 'coverband_test')
+      Coverband.configuration.store.class.class_variable_set(:@@path_cache, {})
       Coverband.configuration.reset
       Coverband::Collectors::Coverage.instance.reset_instance
+      Coverband::Utils::RelativeFileConverter.reset
+      Coverband::Utils::AbsoluteFileConverter.reset
+      Coverband.configuration.redis_namespace = 'coverband_test'
       Coverband::Background.stop
+      Coverband.configuration.store.instance_variable_set(:@redis, redis)
+      redis.flushdb
     end
 
     def setup
@@ -60,6 +77,7 @@ def test(name, &block)
               false
             end
   raise "#{test_name} is already defined in #{self}" if defined
+
   if block_given?
     define_method(test_name, &block)
   else
@@ -69,10 +87,8 @@ def test(name, &block)
   end
 end
 
-def mock_file_hash
-  mock_file = mock('mock_file')
-  mock_file.expects(:hexdigest).at_least_once.returns('abcd')
-  Digest::MD5.expects(:file).at_least_once.returns(mock_file)
+def mock_file_hash(hash: 'abcd')
+  Coverband::Utils::FileHasher.expects(:hash).at_least_once.returns(hash)
 end
 
 def example_line
@@ -83,16 +99,41 @@ def basic_coverage
   { 'app_path/dog.rb' => example_line }
 end
 
+def basic_coverage_full_path
+  { basic_coverage_file_full_path => example_line }
+end
+
+def basic_source_fixture_coverage
+  { source_fixture('sample.rb') => example_line }
+end
+
+def basic_coverage_file_full_path
+  "#{test_root}/dog.rb"
+end
+
 def source_fixture(filename)
   File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', filename))
 end
 
+def fixtures_root
+  File.expand_path(File.join(File.dirname(__FILE__), 'fixtures'))
+end
+
 def test_root
   File.expand_path(File.join(File.dirname(__FILE__)))
 end
 
+###
+# This handles an issue where the store is setup in tests prior to being able to set the namespace
+###
 def store
-  Coverband.configuration.store
+  if Coverband.configuration.store.redis_namespace == 'coverband_test'
+    Coverband.configuration.store
+  else
+    Coverband.configuration.redis_namespace = 'coverband_test'
+    Coverband.configuration.instance_variable_set(:@store, nil)
+    Coverband.configuration.store
+  end
 end
 
 # Taken from http://stackoverflow.com/questions/4459330/how-do-i-temporarily-redirect-stderr-in-ruby

data/test/unique_files.rb

@@ -2,22 +2,30 @@
 
 require 'securerandom'
 require 'fileutils'
+require 'erb'
+require 'ostruct'
 
-UNIQUE_FILES_DIR = "./test/unique_files"
+UNIQUE_FILES_DIR = './test/unique_files'
 
-def require_unique_file(file = 'dog.rb')
-  dir = "#{UNIQUE_FILES_DIR}/#{SecureRandom.uuid}"
-  FileUtils.mkdir_p(dir)
-  temp_file = "#{dir}/#{file}"
-  File.open(temp_file, 'w'){ |w| w.write(File.read("./test/#{file}")) }
+def require_unique_file(file = 'dog.rb', variables = {})
+  uuid = SecureRandom.uuid
+  dir = "#{UNIQUE_FILES_DIR}/#{uuid}"
+  file_name = file.sub('.erb', '')
+  temp_file = "#{dir}/#{file_name}"
+  FileUtils.mkdir_p(Pathname.new(temp_file).dirname.to_s)
+  file_contents = File.read("./test/#{file}")
+  file_contents = ERB.new(file_contents).result(OpenStruct.new(variables).instance_eval { binding }) if variables.any?
+  File.open(temp_file, 'w') { |w| w.write(file_contents) }
   require temp_file
-  temp_file
+  Coverband::Utils::RelativeFileConverter.convert(File.expand_path(temp_file))
 end
 
 def remove_unique_files
   FileUtils.rm_r(UNIQUE_FILES_DIR) if File.exist?(UNIQUE_FILES_DIR)
 end
 
-Minitest.after_run do
-  remove_unique_files
+if defined?(Minitest)
+  Minitest.after_run do
+    remove_unique_files
+  end
 end

data/views/data.erb

@@ -0,0 +1 @@
+<%= result.source_files.to_json %>