coverband 1.5.4 → 2.0.0.alpha

data/test/unit/adapters_memory_cache_store_test.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper', File.dirname(__FILE__))
 
 module Coverband
   class MemoryCacheStoreTest < Test::Unit::TestCase
-
     def setup
       Adapters::MemoryCacheStore.reset!
       @store = mock('store')
@@ -46,12 +47,10 @@ module Coverband
     end
 
     test 'it initializes cache with what is in store' do
-      @store.expects(:covered_lines_for_file).with('file1').returns [3,5]
+      @store.expects(:covered_lines_for_file).with('file1').returns [3, 5]
       @store.expects(:covered_lines_for_file).with('file2').returns [2]
       @store.expects(:save_report).with('file2' => { 1 => 1 })
       @memory_store.save_report data
     end
-
   end
-
 end

data/test/unit/adapters_redis_store_test.rb

@@ -1,37 +1,42 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper', File.dirname(__FILE__))
 
 class RedisTest < Test::Unit::TestCase
   BASE_KEY = Coverband::Adapters::RedisStore::BASE_KEY
 
+  def example_hash
+    {'1' => '1', '2' => '2'}
+  end
+
   def setup
     @redis = Redis.new
     @redis.flushdb
-    @store = Coverband::Adapters::RedisStore.new(@redis, array: true)
+    @store = Coverband::Adapters::RedisStore.new(@redis)
   end
 
   def test_coverage
     @redis.sadd(BASE_KEY, 'dog.rb')
-    @redis.sadd("#{BASE_KEY}.dog.rb", 1)
-    @redis.sadd("#{BASE_KEY}.dog.rb", 2)
-    expected = {'dog.rb' => [1,2]}
+    @store.send(:store_map, "#{BASE_KEY}.dog.rb", example_hash)
+    expected = { 'dog.rb' => example_hash }
     assert_equal expected, @store.coverage
   end
 
   def test_covered_lines_for_file
-    @redis.sadd("#{BASE_KEY}.dog.rb", 1)
-    @redis.sadd("#{BASE_KEY}.dog.rb", 2)
-    assert_equal [1, 2], @store.covered_lines_for_file('dog.rb').sort
+    @store.send(:store_map, "#{BASE_KEY}.dog.rb", example_hash)
+    assert_equal [["1", "1"], ["2", "2"]], @store.covered_lines_for_file('dog.rb').sort
   end
 
   def test_covered_lines_for_file__hash
-    @redis.mapped_hmset("#{BASE_KEY}.dog.rb", {"1" => 1, "2" => 2})
-    @store = Coverband::Adapters::RedisStore.new(@redis, array: false)
-    expected = [["1", "1"], ["2", "2"]]
+    @redis.mapped_hmset("#{BASE_KEY}.dog.rb", '1' => 1, '2' => 2)
+    @store = Coverband::Adapters::RedisStore.new(@redis)
+    expected = [%w[1 1], %w[2 2]]
     assert_equal expected, @store.covered_lines_for_file('dog.rb').sort
   end
 
   def test_covered_lines_when_null
-    assert_equal @store.covered_lines_for_file('dog.rb'),  []
+    empty_hash = {}
+    assert_equal empty_hash, @store.covered_lines_for_file('dog.rb')
   end
 
   def test_clear
@@ -44,121 +49,40 @@ class RedisTest < Test::Unit::TestCase
 
   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 }
+      '/Users/danmayer/projects/cover_band_server/app.rb' => { 54 => 1, 55 => 2 },
+      '/Users/danmayer/projects/cover_band_server/server.rb' => { 5 => 1 }
     }
   end
 end
 
-class RedisStoreTestV3Array < RedisTest
-
-    def setup
-      @redis = Redis.current.tap { |redis|
-        redis.stubs(:sadd).with(anything, anything)
-        redis.stubs(:info).returns({'redis_version' => 3.0})
-      }
-
-      @store = Coverband::Adapters::RedisStore.new(@redis, array: true)
-    end
-
-    test "it stores the files into coverband" do
-      @redis.expects(:sadd).with(BASE_KEY, [
-        '/Users/danmayer/projects/cover_band_server/app.rb',
-        '/Users/danmayer/projects/cover_band_server/server.rb'
-      ])
-
-      @store.save_report(test_data)
-    end
-
-    test "it stores the file lines of the file app.rb" do
-      @redis.expects(:sadd).with(
-        "#{BASE_KEY}./Users/danmayer/projects/cover_band_server/app.rb",
-        [54, 55]
-      )
-
-      @store.save_report(test_data)
-    end
-
-    test "it stores the file lines of the file server.rb" do
-      @redis.expects(:sadd).with(
-        "#{BASE_KEY}./Users/danmayer/projects/cover_band_server/server.rb",
-        [5]
-      )
-
-      @store.save_report(test_data)
-    end
-
-end
-
 class RedisStoreTestV3Hash < RedisTest
-
-    def setup
-      @redis = Redis.current.tap { |redis|
-        redis.stubs(:sadd).with(anything, anything)
-        redis.stubs(:info).returns({'redis_version' => 3.0})
-      }
-
-      @store = Coverband::Adapters::RedisStore.new(@redis)
-    end
-
-    test "it stores the files into coverband" do
-      @redis.expects(:sadd).with(BASE_KEY, [
-        '/Users/danmayer/projects/cover_band_server/app.rb',
-        '/Users/danmayer/projects/cover_band_server/server.rb'
-      ])
-
-      @store.save_report(test_data)
-    end
-
-    test "it stores the file lines of the file app.rb" do
-      @redis.expects(:mapped_hmset).with(
-        "#{BASE_KEY}./Users/danmayer/projects/cover_band_server/app.rb",
-        {'54' => 1, '55' => 2}
-      )
-      @redis.expects(:mapped_hmset).with(
-        "#{BASE_KEY}./Users/danmayer/projects/cover_band_server/server.rb",
-        {'5' => 1}
-      )
-
-      @store.save_report(test_data)
-    end
-
-end
-
-class RedisStoreTestV223 < RedisTest
-
-    def setup
-      @redis = Redis.current.tap { |redis|
-        redis.stubs(:sadd).with(anything, anything)
-        redis.stubs(:info).returns({'redis_version' => "2.2.3"})
-      }
-
-      @store = Coverband::Adapters::RedisStore.new(@redis, array: true)
-    end
-
-    test "it store the files with separate calls into coverband" do
-      @redis.expects(:sadd).with(BASE_KEY, '/Users/danmayer/projects/cover_band_server/app.rb')
-      @redis.expects(:sadd).with(BASE_KEY, '/Users/danmayer/projects/cover_band_server/server.rb')
-
-      @store.save_report(test_data)
+  def setup
+    @redis = Redis.current.tap do |redis|
+      redis.stubs(:sadd).with(anything, anything)
     end
-end
 
-class RedisStoreTestV222 < RedisTest
+    @store = Coverband::Adapters::RedisStore.new(@redis)
+  end
 
-    def setup
-      @redis = Redis.current.tap { |redis|
-        redis.stubs(:sadd).with(anything, anything)
-        redis.stubs(:info).returns({'redis_version' => "2.2.2"})
-      }
+  test 'it stores the files into coverband' do
+    @redis.expects(:sadd).with(BASE_KEY, [
+                                 '/Users/danmayer/projects/cover_band_server/app.rb',
+                                 '/Users/danmayer/projects/cover_band_server/server.rb'
+                               ])
 
-      @store = Coverband::Adapters::RedisStore.new(@redis, array: true)
-    end
-
-    test "it store the files with separate calls into coverband" do
-      @redis.expects(:sadd).with(BASE_KEY, '/Users/danmayer/projects/cover_band_server/app.rb')
-      @redis.expects(:sadd).with(BASE_KEY, '/Users/danmayer/projects/cover_band_server/server.rb')
+    @store.save_report(test_data)
+  end
 
-      @store.save_report(test_data)
-    end
+  test 'it stores the file lines of the file app.rb' do
+      @redis.expects(:mapped_hmset).with(
+      "#{BASE_KEY}./Users/danmayer/projects/cover_band_server/app.rb",
+      '54' => 1, '55' => 2
+    )
+    @redis.expects(:mapped_hmset).with(
+      "#{BASE_KEY}./Users/danmayer/projects/cover_band_server/server.rb",
+      '5' => 1
+    )
+
+    @store.save_report(test_data)
+  end
 end

data/test/unit/baseline_test.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper', File.dirname(__FILE__))
 
 class ReporterTest < Test::Unit::TestCase
-
-  test "record baseline" do
+  test 'record baseline' do
     Coverband.configure do |config|
       config.redis             = nil
       config.store             = nil
@@ -10,20 +11,20 @@ class ReporterTest < Test::Unit::TestCase
       config.coverage_file     = '/tmp/fake_file.json'
     end
     Coverage.expects(:start).returns(true).at_least_once
-    Coverage.expects(:result).returns({'fake' => [0,1]}).at_least_once
+    Coverage.expects(:result).returns('fake' => [0, 1]).at_least_once
     File.expects(:open).once
 
     File.expects(:exist?).at_least_once.returns(true)
-    expected = {"filename.rb" => [0,nil,1]}
+    expected = { 'filename.rb' => [0, nil, 1] }
     fake_file_data = expected.to_json
     File.expects(:read).at_least_once.returns(fake_file_data)
 
-    Coverband::Baseline.record{
-      #nothing
-    }
+    Coverband::Baseline.record do
+      # nothing
+    end
   end
 
-  test "parse baseline" do
+  test 'parse baseline' do
     Coverband.configure do |config|
       config.redis             = nil
       config.store             = nil
@@ -31,14 +32,14 @@ class ReporterTest < Test::Unit::TestCase
       config.coverage_file     = '/tmp/fake_file.json'
     end
     File.expects(:exist?).at_least_once.returns(true)
-    expected = {"filename.rb" => [0,nil,1]}
+    expected = { 'filename.rb' => [0, nil, 1] }
     fake_file_data = expected.to_json
     File.expects(:read).at_least_once.returns(fake_file_data)
     results = Coverband::Baseline.parse_baseline
-    assert_equal(results, {"filename.rb" => [0,nil,1]})
+    assert_equal(results, 'filename.rb' => [0, nil, 1])
   end
 
-  test "exclude_files" do
+  test 'exclude_files' do
     Coverband.configure do |config|
       config.redis             = nil
       config.store             = nil
@@ -48,17 +49,13 @@ class ReporterTest < Test::Unit::TestCase
     end
     root = Coverband.configuration.root
     files = [root + '/ignored_file.rb', root + '/fakefile.rb']
-    expected_files =[root + '/fakefile.rb']
+    expected_files = [root + '/fakefile.rb']
     assert_equal(expected_files, Coverband::Baseline.exclude_files(files))
   end
-
-  # todo test redis and file stores baseline
-
-  test "convert_coverage_format" do
-    results = {"fake_file.rb" => [1,nil,0,2]}
-    expected = {"fake_file.rb"=>{1=>1, 3=>0, 4=>2}}
+  
+  test 'convert_coverage_format' do
+    results = { 'fake_file.rb' => [1, nil, 0, 2] }
+    expected = { 'fake_file.rb' => { 1 => 1, 3 => 0, 4 => 2 } }
     assert_equal(expected, Coverband::Baseline.convert_coverage_format(results))
   end
-
-
 end

data/test/unit/collectors_base_test.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+require File.expand_path('./dog', File.dirname(__FILE__))
+
+class CollectorsBaseTest < Test::Unit::TestCase
+  test 'defaults to a redis store' do
+    coverband = Coverband::Collectors::Base.instance.reset_instance
+    assert_equal Coverband::Adapters::RedisStore, coverband.instance_variable_get('@store').class
+  end
+
+  test 'configure memory caching' do
+    Coverband.configuration.memory_caching = true
+    coverband = Coverband::Collectors::Base.instance.reset_instance
+    assert_equal Coverband::Adapters::MemoryCacheStore, coverband.instance_variable_get('@store').class
+    Coverband.configuration.memory_caching = false
+  end
+
+  test 'start should enable coverage' do
+    coverband = Coverband::Collectors::Base.instance.reset_instance
+    assert_equal false, coverband.instance_variable_get('@enabled')
+    coverband.expects(:record_coverage).once
+    coverband.start
+    assert_equal true, coverband.instance_variable_get('@enabled')
+  end
+
+  test 'stop should disable coverage' do
+    coverband = Coverband::Collectors::Base.instance.reset_instance
+    assert_equal false, coverband.instance_variable_get('@enabled')
+    coverband.expects(:record_coverage).once
+    coverband.start
+    assert_equal true, coverband.instance_variable_get('@enabled')
+    coverband.stop
+    assert_equal false, coverband.instance_variable_get('@enabled')
+    assert_equal false, coverband.instance_variable_get('@tracer_set')
+  end
+
+  test 'allow for sampling with a block and enable when 100 percent sample' do
+    logger = Logger.new(STDOUT)
+    coverband = Coverband::Collectors::Base.instance.reset_instance
+    coverband.instance_variable_set('@sample_percentage', 100.0)
+    coverband.instance_variable_set('@verbose', true)
+    coverband.instance_variable_set('@logger', logger)
+    coverband.instance_variable_set('@store', nil)
+    assert_equal false, coverband.instance_variable_get('@enabled')
+    logger.expects(:info).at_least_once
+    coverband.sample { 1 + 1 }
+    assert_equal true, coverband.instance_variable_get('@enabled')
+  end
+
+  test 'allow reporting with start stop save' do
+    logger = Logger.new(STDOUT)
+    coverband = Coverband::Collectors::Base.instance.reset_instance
+    coverband.instance_variable_set('@sample_percentage', 100.0)
+    coverband.instance_variable_set('@verbose', true)
+    coverband.instance_variable_set('@logger', logger)
+    coverband.instance_variable_set('@store', nil)
+    assert_equal false, coverband.instance_variable_get('@enabled')
+    logger.expects(:info).at_least_once
+    coverband.start
+    logger.info(1 + 1)
+    coverband.stop
+    coverband.save
+  end
+
+  test 'allow reporting to redis start stop save' do
+    dog_file = File.expand_path('./dog.rb', File.dirname(__FILE__))
+    coverband = Coverband::Collectors::Base.instance.reset_instance
+    coverband.instance_variable_set('@sample_percentage', 100.0)
+    coverband.instance_variable_set('@verbose', true)
+    Coverband.configuration.logger.stubs('info')
+    store = Coverband::Adapters::RedisStore.new(Redis.new)
+    coverband.instance_variable_set('@store', store)
+    store.expects(:save_report).once.with(has_entries(dog_file => { 5 => 5 }))
+    assert_equal false, coverband.instance_variable_get('@enabled')
+    coverband.start
+    5.times { Dog.new.bark }
+    coverband.stop
+    coverband.save
+  end
+
+  test 'tracer should count line numbers' do
+    dog_file = File.expand_path('./dog.rb', File.dirname(__FILE__))
+    coverband = Coverband::Collectors::Base.instance.reset_instance
+    coverband.start
+    100.times { Dog.new.bark }
+    assert_equal 100, coverband.instance_variable_get('@file_line_usage')[dog_file][5]
+    coverband.stop
+    coverband.save
+  end
+
+  test 'sample should return the result of the block' do
+    coverband = Coverband::Collectors::Base.instance.reset_instance
+    assert_equal 2, coverband.sample { 1 + 1 }
+  end
+end

data/test/unit/collectors_coverage_test.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+require File.expand_path('./dog', File.dirname(__FILE__))
+
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.3.0')
+  class CollectorsCoverageTest < Test::Unit::TestCase
+    attr_accessor :coverband
+
+    def setup
+      Thread.current[:coverband_instance] = nil
+      Coverband.configure do |config|
+        config.collector = 'coverage'
+      end
+      @coverband = Coverband::Collectors::Base.instance.reset_instance
+    end
+
+    def teardown
+      Thread.current[:coverband_instance] = nil
+      Coverband.configure do |config|
+        config.collector = 'trace'
+      end
+      @coverband = Coverband::Collectors::Base.instance.reset_instance
+    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 'configure memory caching' do
+      Coverband.configuration.memory_caching = true
+      coverband = Coverband::Collectors::Base.instance.reset_instance
+      assert_equal Coverband::Adapters::MemoryCacheStore, coverband.instance_variable_get('@store').class
+      Coverband.configuration.memory_caching = false
+    end
+
+    test 'start should enable coverage' do
+      assert_equal false, coverband.instance_variable_get('@enabled')
+      coverband.expects(:record_coverage).once
+      coverband.start
+      assert_equal true, coverband.instance_variable_get('@enabled')
+    end
+
+    test 'stop should disable coverage' do
+      assert_equal false, coverband.instance_variable_get('@enabled')
+      coverband.expects(:record_coverage).once
+      coverband.start
+      assert_equal true, coverband.instance_variable_get('@enabled')
+      coverband.stop
+      assert_equal false, coverband.instance_variable_get('@enabled')
+    end
+
+    test 'allow for sampling with a block and enable when 100 percent sample' do
+      logger = Logger.new(STDOUT)
+      coverband.instance_variable_set('@sample_percentage', 100.0)
+      coverband.instance_variable_set('@verbose', true)
+      coverband.instance_variable_set('@logger', logger)
+      coverband.instance_variable_set('@store', nil)
+      assert_equal false, coverband.instance_variable_get('@enabled')
+      logger.expects(:info).at_least_once
+      coverband.sample { 1 + 1 }
+      assert_equal true, coverband.instance_variable_get('@enabled')
+    end
+
+    test 'allow reporting with start stop save' do
+      logger = Logger.new(STDOUT)
+      coverband.instance_variable_set('@sample_percentage', 100.0)
+      coverband.instance_variable_set('@verbose', true)
+      coverband.instance_variable_set('@logger', logger)
+      coverband.instance_variable_set('@store', nil)
+      assert_equal false, coverband.instance_variable_get('@enabled')
+      logger.expects(:info).at_least_once
+      coverband.start
+      logger.info(1 + 1)
+      coverband.stop
+      coverband.save
+    end
+
+    test 'allow reporting to redis start stop save' do
+      dog_file = File.expand_path('./dog.rb', File.dirname(__FILE__))
+      coverband.instance_variable_set('@sample_percentage', 100.0)
+      coverband.instance_variable_set('@verbose', true)
+      Coverband.configuration.logger.stubs('info')
+      store = Coverband::Adapters::RedisStore.new(Redis.new)
+      coverband.instance_variable_set('@store', store)
+
+      prior = Coverage.peek_result[dog_file].dup
+      prior[4] = prior[4] + 5
+      expected = {}
+      prior.each_with_index do |count, index|
+        expected[(index + 1)] = count if count
+      end
+
+      store.expects(:save_report).once.with(has_entries(dog_file => expected))
+      assert_equal false, coverband.instance_variable_get('@enabled')
+      coverband.start
+      5.times { Dog.new.bark }
+      coverband.stop
+      coverband.save
+    end
+
+    test 'coverage should count line numbers only the new calls' do
+      dog_file = File.expand_path('./dog.rb', File.dirname(__FILE__))
+      coverband.instance_variable_set('@sample_percentage', 100.0)
+      coverband.instance_variable_set('@store', nil)
+      original_count = Coverage.peek_result[dog_file][4]
+      coverband.start
+      100.times { Dog.new.bark }
+      coverband.stop
+      coverband.save
+      assert_equal (original_count + 100), coverband.instance_variable_get('@file_line_usage')[dog_file][5]
+      50.times { Dog.new.bark }
+      coverband.save
+      assert_equal 50, coverband.instance_variable_get('@file_line_usage')[dog_file][5]
+    end
+
+    test 'coverage should count line numbers' do
+      dog_file = File.expand_path('./dog.rb', File.dirname(__FILE__))
+      coverband.instance_variable_set('@sample_percentage', 100.0)
+      coverband.instance_variable_set('@store', nil)
+      original_count = Coverage.peek_result[dog_file][4]
+      coverband.start
+      100.times { Dog.new.bark }
+      coverband.stop
+      coverband.save
+      assert_equal (original_count + 100), coverband.instance_variable_get('@file_line_usage')[dog_file][5]
+    end
+
+    test 'sample should return the result of the block' do
+      assert_equal 2, coverband.sample { 1 + 1 }
+    end
+  end
+end