coverband 1.3.1 → 1.5.0

data/test/test_helper.rb

@@ -28,6 +28,26 @@ def test(name, &block)
   end
 end
 
+def fake_redis
+  @redis ||= begin
+    redis = OpenStruct.new()
+    def redis.smembers(key)
+    end
+    redis
+  end
+end
+
+def fake_coverband_members
+  ["/Users/danmayer/projects/hearno/script/tester.rb",
+   "/Users/danmayer/projects/hearno/app/controllers/application_controller.rb",
+   "/Users/danmayer/projects/hearno/app/models/account.rb"
+  ]
+end
+
+def fake_coverage_report
+  {"/Users/danmayer/projects/hearno/script/tester.rb"=>[1, nil, 1, 1, nil, nil, nil]}
+end
+
 require 'coverband'
 
 unless File.exist?('./tmp/coverband_baseline.json')

data/test/unit/adapters_file_store_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+class AdaptersFileStoreTest < Test::Unit::TestCase
+
+  def setup
+    @test_file_path = "/tmp/coverband_filestore_test_path.json"
+    File.open(@test_file_path, 'w') { |f| f.write(test_data.to_json) }
+    @store = Coverband::Adapters::FileStore.new(@test_file_path)
+  end
+
+  def test_covered_lines_for_file
+    assert_equal @store.covered_lines_for_file('dog.rb')["1"],  1
+    assert_equal @store.covered_lines_for_file('dog.rb')["2"],  2
+  end
+
+  def test_covered_lines_when_null
+    assert_equal @store.covered_lines_for_file('none.rb'),  []
+  end
+
+  def test_covered_files
+    assert_equal @store.covered_files(),  ['dog.rb']
+  end
+
+  def test_clear
+    @store.clear!
+    assert_equal false,  File.exist?(@test_file_path)
+  end
+
+  def test_save_report
+    @store.save_report({"cat.rb" => {1 => 1}})
+    assert_equal @store.covered_lines_for_file('cat.rb')["1"],  1
+  end
+
+  private
+
+  def test_data
+    {
+      "dog.rb" => { 1 => 1, 2 => 2 },
+    }
+  end
+end

data/test/unit/{memory_cache_store_test.rb → adapters_memory_cache_store_test.rb}

@@ -4,9 +4,9 @@ module Coverband
   class MemoryCacheStoreTest < Test::Unit::TestCase
 
     def setup
-      MemoryCacheStore.reset!
+      Adapters::MemoryCacheStore.reset!
       @store = mock('store')
-      @memory_store = MemoryCacheStore.new(@store)
+      @memory_store = Adapters::MemoryCacheStore.new(@store)
     end
 
     def data
@@ -17,17 +17,17 @@ module Coverband
     end
 
     test 'it passes data into store' do
-      @store.expects(:store_report).with data
+      @store.expects(:save_report).with data
       @store.expects(:covered_lines_for_file).with('file1').returns []
       @store.expects(:covered_lines_for_file).with('file2').returns []
-      @memory_store.store_report data
+      @memory_store.save_report data
     end
 
     test 'it passes data into store only once' do
-      @store.expects(:store_report).once.with data
+      @store.expects(:save_report).once.with data
       @store.expects(:covered_lines_for_file).with('file1').returns []
       @store.expects(:covered_lines_for_file).with('file2').returns []
-      2.times { @memory_store.store_report data }
+      2.times { @memory_store.save_report data }
     end
 
     test 'it only passes files and lines we have not hit yet' do
@@ -37,19 +37,19 @@ module Coverband
       }
       @store.expects(:covered_lines_for_file).with('file1').returns []
       @store.expects(:covered_lines_for_file).with('file2').returns []
-      @store.expects(:store_report).once.with data
-      @store.expects(:store_report).once.with(
+      @store.expects(:save_report).once.with data
+      @store.expects(:save_report).once.with(
         'file1' => { 10 => 1 }
       )
-      @memory_store.store_report data
-      @memory_store.store_report second_data
+      @memory_store.save_report data
+      @memory_store.save_report second_data
     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('file2').returns [2]
-      @store.expects(:store_report).with('file2' => { 1 => 1 })
-      @memory_store.store_report data
+      @store.expects(:save_report).with('file2' => { 1 => 1 })
+      @memory_store.save_report data
     end
 
   end

data/test/unit/adapters_redis_store_test.rb

@@ -0,0 +1,164 @@
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+class RedisTest < Test::Unit::TestCase
+  BASE_KEY = Coverband::Adapters::RedisStore::BASE_KEY
+
+  def setup
+    @redis = Redis.new
+    @redis.flushdb
+    @store = Coverband::Adapters::RedisStore.new(@redis, array: true)
+  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]}
+    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
+  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"]]
+    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'),  []
+  end
+
+  def test_clear
+    @redis.expects(:smembers).with(BASE_KEY).once.returns([])
+    @redis.expects(:del).with(BASE_KEY).once
+    @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
+
+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)
+    end
+end
+
+class RedisStoreTestV222 < RedisTest
+
+    def setup
+      @redis = Redis.current.tap { |redis|
+        redis.stubs(:sadd).with(anything, anything)
+        redis.stubs(:info).returns({'redis_version' => "2.2.2"})
+      }
+
+      @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
+end

data/test/unit/base_test.rb

@@ -5,13 +5,13 @@ class BaseTest < Test::Unit::TestCase
 
   test 'defaults to a redis store' do
     coverband = Coverband::Base.instance.reset_instance
-    assert_equal Coverband::RedisStore, coverband.instance_variable_get('@reporter').class
+    assert_equal Coverband::Adapters::RedisStore, coverband.instance_variable_get('@store').class
   end
 
   test 'configure memory caching' do
     Coverband.configuration.memory_caching = true
     coverband = Coverband::Base.instance.reset_instance
-    assert_equal Coverband::MemoryCacheStore, coverband.instance_variable_get('@reporter').class
+    assert_equal Coverband::Adapters::MemoryCacheStore, coverband.instance_variable_get('@store').class
     Coverband.configuration.memory_caching = false
   end
 
@@ -45,7 +45,7 @@ class BaseTest < Test::Unit::TestCase
     coverband.instance_variable_set("@sample_percentage", 100.0)
     coverband.instance_variable_set("@verbose", true)
     coverband.instance_variable_set("@logger", logger)
-    coverband.instance_variable_set("@reporter", nil)
+    coverband.instance_variable_set("@store", nil)
     assert_equal false, coverband.instance_variable_get("@enabled")
     logger.expects(:info).at_least_once
     coverband.sample { 1 + 1 }
@@ -58,7 +58,7 @@ class BaseTest < Test::Unit::TestCase
     coverband.instance_variable_set("@sample_percentage", 100.0)
     coverband.instance_variable_set("@verbose", true)
     coverband.instance_variable_set("@logger", logger)
-    coverband.instance_variable_set("@reporter", nil)
+    coverband.instance_variable_set("@store", nil)
     assert_equal false, coverband.instance_variable_get("@enabled")
     logger.expects(:info).at_least_once
     coverband.start
@@ -72,9 +72,10 @@ class BaseTest < Test::Unit::TestCase
     coverband = Coverband::Base.instance.reset_instance
     coverband.instance_variable_set("@sample_percentage", 100.0)
     coverband.instance_variable_set("@verbose", true)
-    store = Coverband::RedisStore.new(Redis.new)
-    coverband.instance_variable_set("@reporter", store)
-    store.expects(:store_report).once.with(has_entries(dog_file => { 3 => 5 }) )
+    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 => { 3 => 5 }) )
     assert_equal false, coverband.instance_variable_get("@enabled")
     coverband.start
     5.times { Dog.new.bark }

data/test/unit/baseline_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+class ReporterTest < Test::Unit::TestCase
+
+  test "record baseline" do
+    Coverband.configure do |config|
+      config.redis             = nil
+      config.store             = nil
+      config.root              = '/full/remote_app/path'
+      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
+    File.expects(:open).once
+
+    File.expects(:exist?).at_least_once.returns(true)
+    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
+    }
+  end
+
+  test "parse baseline" do
+    Coverband.configure do |config|
+      config.redis             = nil
+      config.store             = nil
+      config.root              = '/full/remote_app/path'
+      config.coverage_file     = '/tmp/fake_file.json'
+    end
+    File.expects(:exist?).at_least_once.returns(true)
+    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]})
+  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}}
+    assert_equal(expected, Coverband::Baseline.convert_coverage_format(results))
+  end
+
+
+end

data/test/unit/middleware_test.rb

@@ -3,6 +3,8 @@ require File.expand_path('../fake_app/basic_rack', File.dirname(__FILE__))
 require 'rack'
 
 class MiddlewareTest < Test::Unit::TestCase
+  BASE_KEY = Coverband::Adapters::RedisStore::BASE_KEY
+
   test "call app" do
     request = Rack::MockRequest.env_for("/anything.json")
     Coverband::Base.instance.reset_instance
@@ -76,7 +78,6 @@ class MiddlewareTest < Test::Unit::TestCase
     middleware.call(request) rescue nil
   end
 
-
   test 'always report coverage when sampling' do
     request = Rack::MockRequest.env_for("/anything.json")
     Coverband::Base.instance.reset_instance
@@ -84,15 +85,15 @@ class MiddlewareTest < Test::Unit::TestCase
     assert_equal false, Coverband::Base.instance.instance_variable_get("@enabled")
     Coverband::Base.instance.instance_variable_set("@sample_percentage", 100.0)
     fake_redis = Redis.new
-    Coverband::Base.instance.instance_variable_set("@reporter", Coverband::RedisStore.new(fake_redis))
+    Coverband::Base.instance.instance_variable_set("@store", Coverband::Adapters::RedisStore.new(fake_redis))
     fake_redis.stubs(:info).returns({'redis_version' => 3.0})
     fake_redis.expects(:sadd).at_least_once
-    fake_redis.expects(:sadd).at_least_once.with("coverband.#{basic_rack_ruby_file}", [5])
+    fake_redis.expects(:mapped_hmset).at_least_once
+    fake_redis.expects(:mapped_hmset).at_least_once.with("#{BASE_KEY}.#{basic_rack_ruby_file}", {'5' => 1})
     results = middleware.call(request)
     assert_equal true, Coverband::Base.instance.instance_variable_get("@enabled")
   end
 
-
   test 'report only on calls when configured' do
     request = Rack::MockRequest.env_for("/anything.json")
     Coverband.configuration.trace_point_events = [:call]
@@ -101,16 +102,15 @@ class MiddlewareTest < Test::Unit::TestCase
     assert_equal false, Coverband::Base.instance.instance_variable_get("@enabled")
     Coverband::Base.instance.instance_variable_set("@sample_percentage", 100.0)
     fake_redis = Redis.new
-    Coverband::Base.instance.instance_variable_set("@reporter", Coverband::RedisStore.new(fake_redis))
+    Coverband::Base.instance.instance_variable_set("@store", Coverband::Adapters::RedisStore.new(fake_redis))
     fake_redis.stubs(:info).returns({'redis_version' => 3.0})
     fake_redis.expects(:sadd).at_least_once
-    fake_redis.expects(:sadd).at_least_once.with("coverband.#{basic_rack_ruby_file}", [4])
+    fake_redis.expects(:mapped_hmset).at_least_once
+    fake_redis.expects(:mapped_hmset).at_least_once.with("#{BASE_KEY}.#{basic_rack_ruby_file}", {'4'=>1})
     results = middleware.call(request)
     assert_equal true, Coverband::Base.instance.instance_variable_get("@enabled")
   end
 
-
-
   private
 
   def fake_app

data/test/unit/reports_base_test.rb

@@ -0,0 +1,140 @@
+require File.expand_path('../test_helper', File.dirname(__FILE__))
+
+class ReportsBaseTest < Test::Unit::TestCase
+
+  test "filename_from_key fix filename from a key with a swappable path" do
+    Coverband.configure do |config|
+      config.reporter          = 'std_out'
+      config.root              = '/full/remote_app/path'
+    end
+
+    key = "/app/is/a/path.rb"
+    #the code takes config.root expands and adds a '/' for the final path in roots
+    roots = ["/app/", '/full/remote_app/path/']
+
+    assert_equal "/full/remote_app/path/is/a/path.rb", Coverband::Reporters::Base.filename_from_key(key, roots)
+  end
+
+  test "filename_from_key fix filename a changing deploy path with double quotes" do
+    Coverband.configure do |config|
+      config.reporter          = 'std_out'
+      config.root              = '/full/remote_app/path'
+    end
+
+    key = "/box/apps/app_name/releases/20140725203539/app/models/user.rb"
+    # the code takes config.root expands and adds a '/' for the final path in roots
+    # note to get regex to work for changing deploy directories it must be double escaped in double quotes or use single qoutes
+    roots = ["/box/apps/app_name/releases/\\d+/", '/full/remote_app/path/']
+
+    assert_equal "/full/remote_app/path/app/models/user.rb", Coverband::Reporters::Base.filename_from_key(key, roots)
+  end
+
+  test "filename_from_key fix filename a changing deploy path with single quotes" do
+    Coverband.configure do |config|
+      config.reporter          = 'std_out'
+      config.root              = '/full/remote_app/path'
+    end
+
+    key = "/box/apps/app_name/releases/20140725203539/app/models/user.rb"
+    # the code takes config.root expands and adds a '/' for the final path in roots
+    # note to get regex to work for changing deploy directories it must be double escaped in double quotes or use single qoutes
+    roots = ['/box/apps/app_name/releases/\d+/', '/full/remote_app/path/']
+
+    assert_equal "/full/remote_app/path/app/models/user.rb", Coverband::Reporters::Base.filename_from_key(key, roots)
+  end
+
+  test "filename_from_key leave filename from a key with a local path" do
+    Coverband.configure do |config|
+      config.reporter          = 'std_out'
+      config.root              = '/full/remote_app/path'
+    end
+
+    key = "/full/remote_app/path/is/a/path.rb"
+    #the code takes config.root expands and adds a '/' for the final path in roots
+    roots = ["/app/", '/full/remote_app/path/']
+
+    assert_equal "/full/remote_app/path/is/a/path.rb", Coverband::Reporters::Base.filename_from_key(key, roots)
+  end
+
+  test "line_hash gets correct hash entry for a line key" do
+    @fake_redis = fake_redis
+    store = Coverband::Adapters::RedisStore.new(@fake_redis, array: true)
+
+    Coverband.configure do |config|
+      config.redis             = @fake_redis
+      config.reporter          = 'std_out'
+      config.root              = '/full/remote_app/path'
+    end
+
+    key = "/full/remote_app/path/is/a/path.rb"
+    #the code takes config.root expands and adds a '/'
+    roots = ["/app/", '/full/remote_app/path/']
+
+    lines_hit = ['1','3','6']
+    @fake_redis.stubs(:smembers).returns(lines_hit)
+    #expects to show hit counts on 1,3,6
+    expected = {"/full/remote_app/path/is/a/path.rb" => [1,nil,1,nil,nil,1]}
+    File.stubs(:exists?).returns(true)
+    File.stubs(:foreach).returns(['line 1','line2','line3','line4','line5','line6'])
+    
+    assert_equal expected, Coverband::Reporters::Base.line_hash(store, key, roots)
+  end
+
+  test "line_hash adjusts relative paths" do
+    @fake_redis = fake_redis
+    store = Coverband::Adapters::RedisStore.new(@fake_redis, array: true)
+
+    Coverband.configure do |config|
+      config.redis             = @fake_redis
+      config.reporter          = 'std_out'
+      config.root              = '/full/remote_app/path'
+    end
+
+    key = "./is/a/path.rb"
+    #the code takes config.root expands and adds a '/'
+    roots = ["/app/", '/full/remote_app/path/']
+
+    lines_hit = ['1','3','6']
+    @fake_redis.stubs(:smembers).returns(lines_hit)
+    #expects to show hit counts on 1,3,6
+    expected = {"/full/remote_app/path/is/a/path.rb" => [1,nil,1,nil,nil,1]}
+    File.stubs(:exists?).returns(true)
+    File.stubs(:foreach).returns(['line 1','line2','line3','line4','line5','line6'])
+    
+    assert_equal expected, Coverband::Reporters::Base.line_hash(store, key, roots)
+  end
+
+  test "#merge_arrays basic merge preserves order and counts" do
+    first = [0,0,1,0,1]
+    second = [nil,0,1,0,0]
+    expects = [0,0,2,0,1]
+
+    assert_equal expects, Coverband::Reporters::Base.merge_arrays(first, second)
+  end
+
+  test "#merge_arrays basic merge preserves order and counts different lengths" do
+    first = [0,0,1,0,1]
+    second = [nil,0,1,0,0,0,0,1]
+    expects = [0,0,2,0,1,0,0,1]
+
+    assert_equal expects, Coverband::Reporters::Base.merge_arrays(first, second)
+  end
+
+  test "#merge_existing_coverage basic merge preserves order and counts different lengths" do
+    first = {"file.rb" => [0,1,2,nil,nil,nil]}
+    second = {"file.rb" => [0,1,2,nil,0,1,2]}
+    expects = {"file.rb" => [0,2,4,nil,0,1,2]}
+
+    assert_equal expects, Coverband::Reporters::Base.merge_existing_coverage(first, second)
+  end
+
+  test "#merge_existing_coverage mismatched" do
+    first = {"file.rb" => [0,1,2,nil,nil,nil]}
+    second = {"diff.rb" => [0,1,2,nil,0,1,2]}
+    expects = {"file.rb" => [0,1,2,nil,nil,nil],
+               "diff.rb" => [0,1,2,nil,0,1,2]}
+
+    assert_equal expects, Coverband::Reporters::Base.merge_existing_coverage(first, second)
+  end
+
+end