coverband 4.0.1 → 4.2.0

data/test/benchmarks/benchmark.rake

@@ -134,7 +134,7 @@ namespace :benchmarks do
       x.config(time: 12, warmup: 5, suite: suite)
       x.report 'coverband' do
         work
-        Coverband::Collectors::Coverage.instance.report_coverage
+        Coverband.report_coverage(true)
       end
       x.report 'no coverband' do
         work
@@ -176,6 +176,10 @@ namespace :benchmarks do
         @file_hash_cache[file] = Digest::MD5.file(__FILE__).hexdigest
       end
     end
+
+    def store.full_path_to_relative(file)
+      file
+    end
   end
 
   def reporting_speed
@@ -215,12 +219,43 @@ namespace :benchmarks do
     $stdout = previous_out
   end
 
+  def measure_configure_memory
+    require 'memory_profiler'
+    # warmup
+    3.times { Coverband.configure }
+
+    previous_out = $stdout
+    capture = StringIO.new
+    $stdout = capture
+
+    MemoryProfiler.report do
+      10.times do
+        Coverband.configure do |config|
+          redis_url = ENV['CACHE_REDIS_URL'] || ENV['REDIS_URL']
+          config.store = Coverband::Adapters::RedisStore.new(Redis.new(url: redis_url), redis_namespace: 'coverband_data')
+        end
+      end
+    end.pretty_print
+    data = $stdout.string
+    $stdout = previous_out
+    puts data
+    raise 'leaking memory!!!' unless data.match('Total retained:  0 bytes')
+  ensure
+    $stdout = previous_out
+  end
+
   desc 'runs memory reporting on Redis store'
   task memory_reporting: [:setup] do
     puts 'runs memory benchmarking to ensure we dont leak'
     measure_memory
   end
 
+  desc 'runs memory reporting on configure'
+  task memory_configure_reporting: [:setup] do
+    puts 'runs memory benchmarking on configure to ensure we dont leak'
+    measure_configure_memory
+  end
+
   desc 'runs memory leak check via Rails tests'
   task memory_rails: [:setup] do
     puts 'runs memory rails test to ensure we dont leak'

data/test/benchmarks/coverage_fork.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+# This is a small script to illustrate how previous results get wiped out by forking
+# this has implications of forking processes like Resque...
+# this in the end would cause coverage.array_diff
+# with previous results to add NEGATIVE code hits to the stored Coverage
+# which in turn causes all sorts of crazy issues.
+#
+# ruby test/benchmarks/coverage_fork.rb
+# in parent before fork
+# {"/Users/danmayer/projects/coverband/test/dog.rb"=>[nil, nil, 1, 1, 2, nil, nil]}
+# in child after fork
+# {"/Users/danmayer/projects/coverband/test/dog.rb"=>[nil, nil, 0, 0, 0, nil, nil]}
+# now triggering hits
+# {"/Users/danmayer/projects/coverband/test/dog.rb"=>[nil, nil, 0, 0, 3, nil, nil]}
+#
+# I believe this might be related to CoW and GC... not sure
+# http://patshaughnessy.net/2012/3/23/why-you-should-be-excited-about-garbage-collection-in-ruby-2-0
+#
+# NOTE: That the child now has 0 hits where previously method definitions had 1
+# this causes all sorts of bad things to happen.
+require 'coverage'
+Coverage.start
+load './test/dog.rb'
+Dog.new.bark
+Dog.new.bark
+puts 'in parent before fork'
+puts Coverage.peek_result
+fork do
+  puts 'in child after fork'
+  puts Coverage.peek_result
+  puts 'now triggering hits'
+  Dog.new.bark
+  Dog.new.bark
+  Dog.new.bark
+  puts Coverage.peek_result
+end

data/test/{unit/adapters_base_test.rb → coverband/adapters/base_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 AdaptersBaseTest < Minitest::Test
   def setup

data/test/{unit/adapters_file_store_test.rb → coverband/adapters/file_store_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 AdaptersFileStoreTest < Minitest::Test
   def setup

data/test/{unit/adapters_redis_store_test.rb → coverband/adapters/redis_store_test.rb}

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
-require File.expand_path('../test_helper', File.dirname(__FILE__))
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
 
 class RedisTest < Minitest::Test
-  BASE_KEY = Coverband::Adapters::RedisStore::BASE_KEY
+  REDIS_STORAGE_FORMAT_VERSION = Coverband::Adapters::RedisStore::REDIS_STORAGE_FORMAT_VERSION
 
   def setup
     super
     @redis = Redis.new
     @store = Coverband::Adapters::RedisStore.new(@redis)
-    @store.clear!
   end
 
   def test_coverage
@@ -34,6 +33,31 @@ class RedisTest < Minitest::Test
     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']
+    end
+
+    @store.type = nil
+    assert_equal [], @store.coverage.keys
+  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_covered_lines_for_file
     mock_file_hash
     expected = basic_coverage
@@ -46,16 +70,9 @@ class RedisTest < Minitest::Test
   end
 
   def test_clear
-    @redis.expects(:del).with(BASE_KEY).once
+    @redis.expects(:del).twice
     @store.clear!
   end
 
-  private
 
-  def test_data
-    {
-      '/Users/danmayer/projects/cover_band_server/app.rb' => { 54 => 1, 55 => 2 },
-      '/Users/danmayer/projects/cover_band_server/server.rb' => { 5 => 1 }
-    }
-  end
 end

data/test/coverband/at_exit_test.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+class AtExitTest < Minitest::Test
+  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 }
+  end
+end
+
+

data/test/coverband/collectors/coverage_test.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+class CollectorsCoverageTest < Minitest::Test
+  attr_accessor :coverband
+
+  def setup
+    super
+    Coverband.configure do |config|
+      config.store = Coverband::Adapters::RedisStore.new(Redis.new)
+    end
+    @coverband = Coverband::Collectors::Coverage.instance.reset_instance
+    # preload first coverage hit
+    @coverband.report_coverage(true)
+  end
+
+  def teardown
+    Thread.current[:coverband_instance] = nil
+    Coverband.configure do |config|
+    end
+    @coverband = Coverband::Collectors::Coverage.instance.reset_instance
+  end
+
+  test 'Dog class coverage' do
+    file = require_unique_file
+    coverband.report_coverage(true)
+    coverage = Coverband.configuration.store.coverage
+    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)
+    coverage = Coverband.configuration.store.coverage
+    assert_equal(coverage["./test/dog.rb"]["data"], [nil, nil, 1, 1, 1, nil, nil])
+  end
+
+  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
+  end
+
+  test 'report_coverage raises errors in tests' do
+    @coverband.reset_instance
+    @coverband.expects(:ready_to_report?).raises('Oh no')
+    assert_raises RuntimeError do
+      @coverband.report_coverage
+    end
+  end
+
+  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.expects(:ready_to_report?).raises('Oh no')
+    logger.expects(:error).times(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
+end

data/test/coverband/collectors/delta_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+require './lib/coverband/collectors/delta'
+
+class CollectorsDeltaTest < Minitest::Test
+  class MockSystemCoverage < Struct.new(:results)
+  end
+
+  def mock_coverage(coverage)
+    MockSystemCoverage.new(coverage)
+  end
+
+  def setup
+    Coverband::Collectors::Delta.reset
+  end
+
+  test 'No previous results' do
+    current_coverage = {
+      '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
+    current_coverage = {
+      '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]
+    }
+    results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
+    assert_equal({'car.rb' => [nil, 0, 2, 0]}, results)
+  end
+
+  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]
+    }
+    results = Coverband::Collectors::Delta.results(mock_coverage(current_coverage))
+    assert_equal(current_coverage, results)
+  end
+end
+

data/test/coverband/configuration_test.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+class BaseTest < Minitest::Test
+  def setup
+    super
+    Coverband.configure do |config|
+      config.root                = Dir.pwd
+      config.s3_bucket           = nil
+      config.root_paths          = ['/app_path/']
+      config.ignore              = ['vendor']
+      config.reporting_frequency = 100.0
+      config.reporter            = 'std_out'
+      config.store               = Coverband::Adapters::RedisStore.new(Redis.new)
+    end
+  end
+
+  test 'defaults' do
+    coverband = Coverband::Collectors::Coverage.instance.reset_instance
+    assert_equal ['vendor', 'internal:prelude', 'schema.rb'], coverband.instance_variable_get('@ignore_patterns')
+  end
+
+  test 'gem_paths' do
+    Coverband::Collectors::Coverage.instance.reset_instance
+    assert Coverband.configuration.gem_paths.first != nil
+  end
+
+  test 'groups' do
+    Coverband::Collectors::Coverage.instance.reset_instance
+    Coverband.configuration.track_gems = true
+    assert_equal %w(App Gems), Coverband.configuration.groups.keys
+  end
+
+  test 'all_root_paths' do
+    Coverband::Collectors::Coverage.instance.reset_instance
+    current_paths = Coverband.configuration.root_paths.dup
+    # verify previous bug fix
+    # it would extend the root_paths instance variable on each invokation
+    Coverband.configuration.all_root_paths
+    Coverband.configuration.all_root_paths
+    assert_equal current_paths, Coverband.configuration.root_paths
+  end
+
+  test 's3 options' do
+    Coverband::Collectors::Coverage.instance.reset_instance
+    Coverband.configure do |config|
+      config.s3_bucket = 'bucket'
+      config.s3_region = 'region'
+      config.s3_access_key_id = 'key_id'
+      config.s3_secret_access_key = 'secret'
+    end
+    assert_equal 'bucket', Coverband.configuration.s3_bucket
+    assert_equal 'region', Coverband.configuration.s3_region
+    assert_equal 'key_id', Coverband.configuration.s3_access_key_id
+    assert_equal 'secret', Coverband.configuration.s3_secret_access_key
+  end
+
+  test 'store raises issues' do
+    Coverband::Collectors::Coverage.instance.reset_instance
+    assert_raises RuntimeError do
+      Coverband.configure do |config|
+        config.store = 'fake'
+      end
+    end
+  end
+end

data/test/{unit → coverband}/coverband_test.rb

@@ -23,4 +23,11 @@ class CoverbandTest < Minitest::Test
     Coverband::Background.expects(:start).never
     ::Coverband.start
   end
+
+  test 'Eager load coverage' do
+    Coverband.eager_loading_coverage!
+    assert_equal :eager_loading, Coverband.configuration.store.type
+    Coverband.runtime_coverage!
+    assert_nil Coverband.configuration.store.type
+  end
 end

data/test/coverband/integrations/background_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+class BackgroundTest < Minitest::Test
+  class ThreadDouble < Struct.new(:alive)
+    def exit
+    end
+
+    def alive?
+      alive
+    end
+  end
+
+  def test_start
+    Thread.expects(:new).yields.returns(ThreadDouble.new(true))
+    Coverband::Background.expects(:loop).yields
+    Coverband::Background.expects(:sleep).with(30)
+    Coverband::Collectors::Coverage.instance.expects(:report_coverage).once
+    2.times { Coverband::Background.start }
+  end
+
+  def test_start_dead_thread
+    Thread.expects(:new).yields.returns(ThreadDouble.new(false)).twice
+    Coverband::Background.expects(:loop).yields.twice
+    Coverband::Background.expects(:sleep).with(30).twice
+    Coverband::Collectors::Coverage.instance.expects(:report_coverage).twice
+    2.times { Coverband::Background.start }
+  end
+
+end

data/test/{unit → coverband/integrations}/middleware_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__))
 require 'rack'
 
 class MiddlewareTest < Minitest::Test
-  BASE_KEY = Coverband::Adapters::RedisStore::BASE_KEY
+  REDIS_STORAGE_FORMAT_VERSION = Coverband::Adapters::RedisStore::REDIS_STORAGE_FORMAT_VERSION
 
   def setup
     super
@@ -62,6 +62,7 @@ class MiddlewareTest < Minitest::Test
     request = Rack::MockRequest.env_for('/anything.json')
     Coverband::Collectors::Coverage.instance.reset_instance
     collector = Coverband::Collectors::Coverage.instance
+    collector.report_coverage(true)
     collector.instance_variable_set('@reporting_frequency', 100.0)
     middleware = Coverband::Middleware.new(fake_app)
     store = Coverband::Collectors::Coverage.instance.instance_variable_get('@store')

data/test/{unit/rack_server_checkout_test.rb → coverband/integrations/rack_server_check_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 RackServerCheckTest < Minitest::Test
   test 'returns true when running in rack server' do

data/test/coverband/integrations/resque_worker_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+class ResqueWorkerTest < Minitest::Test
+  def enqueue_and_run_job
+    Resque.enqueue(TestResqueJob)
+    queue = ENV['QUEUE'] ='resque_coverband'
+    worker = Resque::Worker.new
+    worker.startup
+    worker.work_one_job
+  end
+
+  def setup
+    super
+    Coverband.configure do |config|
+      config.background_reporting_enabled = false
+      config.root_paths = ["#{File.expand_path('../', File.dirname(__FILE__))}/"]
+    end
+    Coverband.start
+    redis = Coverband.configuration.store.send(:redis)
+    Resque.redis = redis
+  end
+
+  test 'resque job coverage' do
+    relative_job_file = './integrations/test_resque_job.rb'
+    resque_job_file = File.expand_path('./test_resque_job.rb', File.dirname(__FILE__))
+    require resque_job_file
+
+    enqueue_and_run_job
+
+    assert !Coverband::Background.running?
+
+    # TODO: There is a test only type issue where the test is looking at eager data
+    # it merged eager and eager for merged and runtime is eager
+    Coverband.runtime_coverage!
+    report = Coverband.configuration.store.get_coverage_report
+
+    assert_equal 0, report[Coverband::EAGER_TYPE][relative_job_file]['data'][4]
+    assert_equal 1, report[Coverband::RUNTIME_TYPE][relative_job_file]['data'][4]
+  end
+end

data/test/coverband/integrations/test_resque_job.rb

@@ -0,0 +1,7 @@
+class TestResqueJob
+  @queue = :resque_coverband
+
+  def self.perform
+    "resque job perform"
+  end
+end