coverband 1.5.4 → 2.0.0.alpha

data/test/unit/collectors_trace_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 CollectorsTraceTest < 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/configuration_test.rb

@@ -1,21 +1,21 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper', File.dirname(__FILE__))
 
 class BaseTest < Test::Unit::TestCase
-
-  test "defaults to line trace point event" do
+  test 'defaults to line trace point event' do
     assert_equal Coverband.configuration.trace_point_events, [:line]
   end
 
-  test "defaults to ignore gems" do
+  test 'defaults to ignore gems' do
     assert_equal Coverband.configuration.include_gems, false
-    coverband = Coverband::Base.instance.reset_instance
-    assert_equal ['vendor', 'internal:prelude', 'schema.rb', 'gems'], coverband.instance_variable_get("@ignore_patterns")
+    coverband = Coverband::Collectors::Base.instance.reset_instance
+    assert_equal ['vendor', 'internal:prelude', 'schema.rb', 'gems'], coverband.instance_variable_get('@ignore_patterns')
   end
 
   test "doesn't ignore gems if include_gems = true" do
     Coverband.configuration.include_gems = true
-    coverband = Coverband::Base.instance.reset_instance
-    assert_equal ['vendor', 'internal:prelude', 'schema.rb'], coverband.instance_variable_get("@ignore_patterns")
+    coverband = Coverband::Collectors::Base.instance.reset_instance
+    assert_equal ['vendor', 'internal:prelude', 'schema.rb'], coverband.instance_variable_get('@ignore_patterns')
   end
-
 end

data/test/unit/dog.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 class Dog
   def bark
-    "woof"
+    'woof'
   end
 end

data/test/unit/middleware_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../test_helper', File.dirname(__FILE__))
 require File.expand_path('../fake_app/basic_rack', File.dirname(__FILE__))
 require 'rack'
@@ -5,128 +7,135 @@ 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
+  test 'call app' do
+    request = Rack::MockRequest.env_for('/anything.json')
+    Coverband::Collectors::Base.instance.reset_instance
     middleware = Coverband::Middleware.new(fake_app)
     results = middleware.call(request)
-    assert_equal "/anything.json", results.last
+    assert_equal '/anything.json', results.last
   end
 
   test 'pass all rack lint checks' do
-    Coverband::Base.instance.reset_instance
+    Coverband::Collectors::Base.instance.reset_instance
     app = Rack::Lint.new(Coverband::Middleware.new(fake_app))
     env = Rack::MockRequest.env_for('/hello')
     app.call(env)
   end
 
   test 'always be enabled with sample percentage of 100' do
-    request = Rack::MockRequest.env_for("/anything.json")
-    Coverband::Base.instance.reset_instance
+    request = Rack::MockRequest.env_for('/anything.json')
+    Coverband::Collectors::Base.instance.reset_instance
     middleware = Coverband::Middleware.new(fake_app)
-    assert_equal false, Coverband::Base.instance.instance_variable_get("@enabled")
-    Coverband::Base.instance.instance_variable_set("@sample_percentage", 100.0)
-    results = middleware.call(request)
-    assert_equal true, Coverband::Base.instance.instance_variable_get("@enabled")
+    assert_equal false, Coverband::Collectors::Base.instance.instance_variable_get('@enabled')
+    Coverband::Collectors::Base.instance.instance_variable_set('@sample_percentage', 100.0)
+    middleware.call(request)
+    assert_equal true, Coverband::Collectors::Base.instance.instance_variable_get('@enabled')
   end
 
   test 'never be enabled with sample percentage of 0' do
-    request = Rack::MockRequest.env_for("/anything.json")
-    Coverband::Base.instance.reset_instance
+    request = Rack::MockRequest.env_for('/anything.json')
+    Coverband::Collectors::Base.instance.reset_instance
     middleware = Coverband::Middleware.new(fake_app)
-    assert_equal false, Coverband::Base.instance.instance_variable_get("@enabled")
-    Coverband::Base.instance.instance_variable_set("@sample_percentage", 0.0)
-    results = middleware.call(request)
-    assert_equal false, Coverband::Base.instance.instance_variable_get("@enabled")
+    assert_equal false, Coverband::Collectors::Base.instance.instance_variable_get('@enabled')
+    Coverband::Collectors::Base.instance.instance_variable_set('@sample_percentage', 0.0)
+    middleware.call(request)
+    assert_equal false, Coverband::Collectors::Base.instance.instance_variable_get('@enabled')
   end
 
   test 'always unset function when sampling' do
-    request = Rack::MockRequest.env_for("/anything.json")
-    Coverband::Base.instance.reset_instance
+    request = Rack::MockRequest.env_for('/anything.json')
+    Coverband::Collectors::Base.instance.reset_instance
     middleware = Coverband::Middleware.new(fake_app)
-    assert_equal false, Coverband::Base.instance.instance_variable_get("@tracer_set")
-    Coverband::Base.instance.instance_variable_set("@sample_percentage", 100.0)
-    results = middleware.call(request)
-    assert_equal false, Coverband::Base.instance.instance_variable_get("@tracer_set")
+    assert_equal false, Coverband::Collectors::Base.instance.instance_variable_get('@tracer_set')
+    Coverband::Collectors::Base.instance.instance_variable_set('@sample_percentage', 100.0)
+    middleware.call(request)
+    assert_equal false, Coverband::Collectors::Base.instance.instance_variable_get('@tracer_set')
   end
 
   test 'always unset function when not sampling' do
-    request = Rack::MockRequest.env_for("/anything.json")
-    Coverband::Base.instance.reset_instance
+    request = Rack::MockRequest.env_for('/anything.json')
+    Coverband::Collectors::Base.instance.reset_instance
     middleware = Coverband::Middleware.new(fake_app)
-    assert_equal false, Coverband::Base.instance.instance_variable_get("@tracer_set")
-    middleware.instance_variable_set("@sample_percentage", 0.0)
-    results = middleware.call(request)
-    assert_equal false, Coverband::Base.instance.instance_variable_get("@tracer_set")
+    assert_equal false, Coverband::Collectors::Base.instance.instance_variable_get('@tracer_set')
+    middleware.instance_variable_set('@sample_percentage', 0.0)
+    middleware.call(request)
+    assert_equal false, Coverband::Collectors::Base.instance.instance_variable_get('@tracer_set')
   end
 
   test 'always record coverage, set trace func, and add_files when sampling' do
-    request = Rack::MockRequest.env_for("/anything.json")
-    Coverband::Base.instance.reset_instance
+    request = Rack::MockRequest.env_for('/anything.json')
+    Coverband::Collectors::Base.instance.reset_instance
     middleware = Coverband::Middleware.new(fake_app)
-    assert_equal false, Coverband::Base.instance.instance_variable_get("@enabled")
-    Coverband::Base.instance.instance_variable_set("@sample_percentage", 100.0)
-    results = middleware.call(request)
-    assert_equal true, Coverband::Base.instance.instance_variable_get("@enabled")
+    assert_equal false, Coverband::Collectors::Base.instance.instance_variable_get('@enabled')
+    Coverband::Collectors::Base.instance.instance_variable_set('@sample_percentage', 100.0)
+    middleware.call(request)
+    assert_equal true, Coverband::Collectors::Base.instance.instance_variable_get('@enabled')
   end
 
   test 'reports coverage when an error is raised' do
-    request = Rack::MockRequest.env_for("/anything.json")
-    Coverband::Base.instance.reset_instance
-    Coverband::Base.instance.expects(:report_coverage).once
+    request = Rack::MockRequest.env_for('/anything.json')
+    Coverband::Collectors::Base.instance.reset_instance
+    Coverband::Collectors::Base.instance.expects(:report_coverage).once
     middleware = Coverband::Middleware.new(fake_app_raise_error)
-    middleware.call(request) rescue nil
+    begin
+      middleware.call(request)
+    rescue StandardError
+      nil
+    end
   end
 
   test 'always report coverage when sampling' do
-    request = Rack::MockRequest.env_for("/anything.json")
-    Coverband::Base.instance.reset_instance
+    request = Rack::MockRequest.env_for('/anything.json')
+    Coverband::Collectors::Base.instance.reset_instance
     middleware = Coverband::Middleware.new(fake_app_with_lines)
-    assert_equal false, Coverband::Base.instance.instance_variable_get("@enabled")
-    Coverband::Base.instance.instance_variable_set("@sample_percentage", 100.0)
+    assert_equal false, Coverband::Collectors::Base.instance.instance_variable_get('@enabled')
+    Coverband::Collectors::Base.instance.instance_variable_set('@sample_percentage', 100.0)
     fake_redis = Redis.new
-    Coverband::Base.instance.instance_variable_set("@store", Coverband::Adapters::RedisStore.new(fake_redis))
-    fake_redis.stubs(:info).returns({'redis_version' => 3.0})
+    redis_store = Coverband::Adapters::RedisStore.new(fake_redis)
+    redis_store.clear!
+    Coverband::Collectors::Base.instance.instance_variable_set('@store', redis_store)
+    fake_redis.stubs(:info).returns('redis_version' => 3.0)
     fake_redis.expects(:sadd).at_least_once
     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")
+    fake_redis.expects(:mapped_hmset).at_least_once.with("#{BASE_KEY}.#{basic_rack_ruby_file}", '7' => 1)
+    middleware.call(request)
+    assert_equal true, Coverband::Collectors::Base.instance.instance_variable_get('@enabled')
   end
 
   test 'report only on calls when configured' do
-    request = Rack::MockRequest.env_for("/anything.json")
+    request = Rack::MockRequest.env_for('/anything.json')
     Coverband.configuration.trace_point_events = [:call]
-    Coverband::Base.instance.reset_instance
+    Coverband::Collectors::Base.instance.reset_instance
     middleware = Coverband::Middleware.new(fake_app_with_lines)
-    assert_equal false, Coverband::Base.instance.instance_variable_get("@enabled")
-    Coverband::Base.instance.instance_variable_set("@sample_percentage", 100.0)
+    assert_equal false, Coverband::Collectors::Base.instance.instance_variable_get('@enabled')
+    Coverband::Collectors::Base.instance.instance_variable_set('@sample_percentage', 100.0)
     fake_redis = Redis.new
-    Coverband::Base.instance.instance_variable_set("@store", Coverband::Adapters::RedisStore.new(fake_redis))
-    fake_redis.stubs(:info).returns({'redis_version' => 3.0})
+    redis_store = Coverband::Adapters::RedisStore.new(fake_redis)
+    redis_store.clear!
+    Coverband::Collectors::Base.instance.instance_variable_set('@store', redis_store)
+    fake_redis.stubs(:info).returns('redis_version' => 3.0)
     fake_redis.expects(:sadd).at_least_once
     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")
+    fake_redis.expects(:mapped_hmset).at_least_once.with("#{BASE_KEY}.#{basic_rack_ruby_file}", '6' => 1)
+    middleware.call(request)
+    assert_equal true, Coverband::Collectors::Base.instance.instance_variable_get('@enabled')
   end
 
   private
 
   def fake_app
-    @app ||= lambda { |env| [200, {'Content-Type' => 'text/plain'}, env['PATH_INFO']] }
+    @fake_app ||= ->(env) { [200, { 'Content-Type' => 'text/plain' }, env['PATH_INFO']] }
   end
 
   def fake_app_raise_error
-    @fake_app_raise_error ||= lambda { raise "sh** happens" }
+    @fake_app_raise_error ||= -> { raise 'sh** happens' }
   end
 
   def fake_app_with_lines
-    @lines_app ||= ::HelloWorld.new
+    @fake_app_with_lines ||= ::HelloWorld.new
   end
 
   def basic_rack_ruby_file
     File.expand_path('../fake_app/basic_rack.rb', File.dirname(__FILE__))
   end
-
 end

data/test/unit/reports_base_test.rb

@@ -1,64 +1,65 @@
+# frozen_string_literal: true
+
 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
+  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/']
+    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)
+    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
+  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"
+    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/']
+    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)
+    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
+  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"
+    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)
+    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
+  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/']
+    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)
+    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
+  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)
+    store = Coverband::Adapters::RedisStore.new(@fake_redis)
 
     Coverband.configure do |config|
       config.redis             = @fake_redis
@@ -66,23 +67,23 @@ class ReportsBaseTest < Test::Unit::TestCase
       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'])
-    
+    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]
+    store.stubs(:covered_lines_for_file).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(:exist?).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
+  test 'line_hash adjusts relative paths' do
     @fake_redis = fake_redis
-    store = Coverband::Adapters::RedisStore.new(@fake_redis, array: true)
+    store = Coverband::Adapters::RedisStore.new(@fake_redis)
 
     Coverband.configure do |config|
       config.redis             = @fake_redis
@@ -90,51 +91,50 @@ class ReportsBaseTest < Test::Unit::TestCase
       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'])
-    
+    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]
+    store.stubs(:covered_lines_for_file).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(:exist?).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]
+  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]
+  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]}
+  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]}
+  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