coverband 4.2.0 → 4.2.2

data/test/coverband/utils/file_list_test.rb

@@ -9,7 +9,7 @@ require File.expand_path('../../test_helper', File.dirname(__FILE__))
 describe Coverband::Utils::FileList do
   subject do
     original_result = {
-      source_fixture('sample.rb') => [nil, 1, 1, 1, nil, nil, 1, 1, nil, nil],
+      source_fixture('sample.rb') => {'first_updated_at' => Time.at(0), 'data' => [nil, 1, 1, 1, nil, nil, 1, 1, nil, nil]},
       source_fixture('app/models/user.rb') => [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil],
       source_fixture('app/controllers/sample_controller.rb') => [nil, 2, 2, 0, nil, nil, 0, nil, nil, nil]
     }
@@ -44,11 +44,11 @@ describe Coverband::Utils::FileList do
     assert_equal [50.0, 80.0, 100.0], subject.covered_percentages
   end
 
-  it 'has the correct least covered file' do
-    assert subject.least_covered_file.match(/sample_controller.rb/)
-  end
-
   it 'has the correct covered strength' do
     assert_equal 0.9285714285714286, subject.covered_strength
   end
+
+  it 'has correct first_seen_at' do
+    assert_equal Time.at(0), subject.first_seen_at
+  end
 end

data/test/coverband/utils/html_formatter_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+class HTMLFormatterTest < Minitest::Test
+  def setup
+    super
+    @redis = Redis.new
+    @store = Coverband::Adapters::RedisStore.new(@redis, redis_namespace: 'coverband_test')
+    @store.clear!
+  end
+
+  test 'generate dynamic content hosted html report' do
+    Coverband.configure do |config|
+      config.store             = @store
+      config.ignore            = ['notsomething.rb']
+    end
+    mock_file_hash
+    @store.send(:save_report, basic_coverage_full_path)
+
+    notice = nil
+    base_path = '/coverage'
+    filtered_report_files = Coverband::Reporters::Base.report(@store, {})
+    html = Coverband::Utils::HTMLFormatter.new(filtered_report_files,
+                                               base_path: base_path,
+                                               notice: notice).format_dynamic_html!
+    assert_match 'loading source data', html
+  end
+
+  test 'generate static HTML report file' do
+    Coverband.configure do |config|
+      config.store             = @store
+      config.ignore            = ['notsomething.rb']
+    end
+    mock_file_hash
+    @store.send(:save_report, basic_coverage_full_path)
+
+    filtered_report_files = Coverband::Reporters::Base.report(@store, {})
+    Coverband::Utils::HTMLFormatter.new(filtered_report_files).format_static_html!
+    html = File.read("#{Coverband.configuration.root}/coverage/index.html")
+    assert_match 'Coverage first seen', html
+  end
+end

data/test/coverband/utils/relative_file_converter_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+module Coverband
+  module Utils
+    class RelativeFileConverterTest < ::Minitest::Test
+      def test_convert
+        converter = RelativeFileConverter.new(['/bar/tmp/'])
+        assert_equal('./gracie.rb', converter.convert('/bar/tmp/gracie.rb'))
+      end
+
+      def test_convert_without_leading_forward_slash
+        converter = RelativeFileConverter.new(['/foo/bar'])
+        assert_equal('./file.rb', converter.convert('/foo/bar/file.rb'))
+      end
+
+      def test_multiple_roots
+        converter = RelativeFileConverter.new(['/bar/tmp/', '/foo/bar/'])
+        assert_equal('./josie.rb', converter.convert('/foo/bar/josie.rb'))
+      end
+
+      def test_no_match
+        converter = RelativeFileConverter.new(['/bar/tmp/', '/foo/bar/'])
+        assert_equal('/foo/josie.rb', converter.convert('/foo/josie.rb'))
+      end
+
+      def test_middle_path_match
+        converter = RelativeFileConverter.new(['/bar/tmp/', '/foo/bar/'])
+        assert_equal('/tmp/foo/bar/josie.rb', converter.convert('/tmp/foo/bar/josie.rb'))
+      end
+
+      def test_already_relative_file
+        converter = RelativeFileConverter.new(['/bar/tmp/', '/foo/bar/'])
+        assert_equal('./foo/bar/josie.rb', converter.convert('./foo/bar/josie.rb'))
+      end
+    end
+  end
+end

data/test/coverband/utils/result_test.rb

@@ -48,57 +48,16 @@ describe 'result' do
         assert_equal [80.0, 80.0, 100.0], subject.covered_percentages
       end
 
-      it 'has accurate least covered file' do
-        assert subject.least_covered_file.match(/sample_controller.rb/)
-      end
-
-      [:covered_percent,
-       :covered_percentages,
-       :least_covered_file,
-       :covered_strength,
-       :covered_lines,
-       :missed_lines,
-       :total_lines].each do |msg|
+      %i[covered_percent
+         covered_percentages
+         covered_strength
+         covered_lines
+         missed_lines
+         total_lines].each do |msg|
         it "responds to #{msg}" do
           assert(subject.respond_to?(msg))
         end
       end
-
-      describe 'dumped with to_hash' do
-        it 'is a hash' do
-          assert subject.to_hash.is_a?(Hash)
-        end
-
-        describe 'loaded back with from_hash' do
-          let(:dumped_result) do
-            Coverband::Utils::Result.from_hash(subject.to_hash)
-          end
-
-          it 'has 3 source files' do
-            assert_equal subject.source_files.count, dumped_result.source_files.count
-          end
-
-          it 'has the same covered_percent' do
-            assert_equal subject.covered_percent, dumped_result.covered_percent
-          end
-
-          it 'has the same covered_percentages' do
-            assert_equal subject.covered_percentages, dumped_result.covered_percentages
-          end
-
-          it 'has the same timestamp' do
-            assert_equal subject.created_at.to_i, dumped_result.created_at.to_i
-          end
-
-          it 'has the same command_name' do
-            assert_equal subject.command_name, dumped_result.command_name
-          end
-
-          it 'has the same original_result' do
-            assert_equal subject.original_result, dumped_result.original_result
-          end
-        end
-      end
     end
   end
 end

data/test/coverband/utils/results_test.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+describe 'results' do
+  describe 'with a (mocked) Coverage.result' do
+    let(:source_file) { Coverband::Utils::SourceFile.new(source_fixture('app/models/user.rb'), run_lines) }
+    let(:eager_lines) { [nil, 1, 1, 0, nil, nil, 1, 0, nil, nil] }
+    let(:run_lines) { [nil, nil, nil, 1, nil, nil, nil,nil, nil, nil] }
+    let(:original_result) do
+      orig = {
+        Coverband::MERGED_TYPE => {source_fixture('app/models/user.rb') => eager_lines},
+      }
+      orig.merge!({Coverband::EAGER_TYPE => {source_fixture('app/models/user.rb') => eager_lines}}) if eager_lines
+      orig.merge!({Coverband::RUNTIME_TYPE => {source_fixture('app/models/user.rb') => run_lines}}) if run_lines
+      orig
+    end
+    subject { Coverband::Utils::Results.new(original_result) }
+
+    describe 'runtime relevant lines is supported' do
+      it 'has correct runtime relevant coverage' do
+        assert_equal 50.0, subject.runtime_relevant_coverage(source_file)
+      end
+
+      it 'has correct runtime relevant lines' do
+        assert_equal 2, subject.runtime_relavent_lines(source_file)
+      end
+    end
+
+    describe 'runtime relevant lines when no runtime coverage exists' do
+      let(:run_lines) { nil }
+
+      it 'has correct runtime relevant lines' do
+        assert_equal 0.0, subject.runtime_relevant_coverage(source_file)
+      end
+
+      it 'has correct runtime relevant lines' do
+        assert_equal 2, subject.runtime_relavent_lines(source_file)
+      end
+    end
+
+    describe 'runtime relevant lines when no eager coverage exists' do
+      let(:eager_lines) { nil }
+
+      it 'has correct runtime relevant lines' do
+        assert_equal 100.0, subject.runtime_relevant_coverage(source_file)
+      end
+
+      it 'has correct runtime relevant lines' do
+        assert_equal 1, subject.runtime_relavent_lines(source_file)
+      end
+    end
+  end
+end

data/test/coverband/utils/s3_report_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../../test_helper', File.dirname(__FILE__))
 
 module Coverband

data/test/coverband/utils/source_file_test.rb

@@ -146,4 +146,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,48 @@
+# 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
+end

data/test/integration/full_stack_test.rb

@@ -6,52 +6,53 @@ 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.store = Coverband::Adapters::RedisStore.new(Redis.new, redis_namespace: 'coverband_test')
       config.s3_bucket = nil
-      config.background_reporting_enabled = false
-      config.root_paths = ["#{File.expand_path('../', File.dirname(__FILE__))}/"]
+      config.background_reporting_enabled = true
       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,13 @@
 Coverband.configure do |config|
   config.root              = Dir.pwd
-  config.store             = Coverband::Adapters::RedisStore.new(Redis.new(url: ENV['REDIS_URL'])) if defined? Redis
+  config.store             = Coverband::Adapters::RedisStore.new(Redis.new(url: ENV['REDIS_URL']), redis_namespace: 'coverband_test') if defined? Redis
   config.ignore            = %w[vendor .erb$ .slim$]
   config.root_paths        = []
-  config.logger              = Rails.logger
+  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/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,13 @@
 Coverband.configure do |config|
   config.root              = Dir.pwd
-  config.store             = Coverband::Adapters::RedisStore.new(Redis.new(url: ENV['REDIS_URL'])) if defined? Redis
+  config.store             = Coverband::Adapters::RedisStore.new(Redis.new(url: ENV['REDIS_URL']), 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 = 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/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
-