coverband 2.0.3 → 3.0.0.alpha

data/lib/coverband/adapters/memory_cache_store.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-###
-# TODO current benchmarks aren't showing much advantage from this wrapped cache approach
-# re-evaluate before 2.0.0 release 
-###
-module Coverband
-  module Adapters
-    class MemoryCacheStore < Base
-      attr_accessor :store
-
-      @@files_cache = {}
-
-      def initialize(store)
-        @store = store
-      end
-
-      def self.clear!
-        @@files_cache.clear
-      end
-
-      def clear!
-        self.class.clear!
-      end
-
-      def save_report(files)
-        filtered_files = filter(files)
-        store.save_report(filtered_files) if filtered_files.any?
-      end
-
-      private
-
-      def files_cache
-        @@files_cache
-      end
-
-      def filter(files)
-        files.each_with_object({}) do |(file, covered_lines), filtered_file_hash|
-          if covered_lines != cached_file(file)
-            files_cache[file] = covered_lines
-            filtered_file_hash[file] = covered_lines
-          end
-        end
-      end
-
-      def cached_file(file)
-        files_cache[file]  ||= store.covered_lines_for_file(file).each_with_object({}) do |(line_number, value), hash|
-          hash[line_number.to_i] = value.to_i
-        end
-      end
-    end
-  end
-end

data/lib/coverband/collectors/base.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-####
-# TODO refactor this along with the coverage and trace collector
-####
-module Coverband
-  module Collectors
-    class Base
-      def self.instance
-        if Coverband.configuration.collector == 'trace'
-          Thread.current[:coverband_instance] ||= Coverband::Collectors::Trace.new
-        elsif Coverband.configuration.collector == 'coverage'
-          Thread.current[:coverband_instance] ||= Coverband::Collectors::Coverage.new
-        else
-          raise 'select valid collector [trace, coverage]'
-        end
-      end
-
-      def start
-        @enabled = true
-        record_coverage
-      end
-
-      def stop
-        @enabled = false
-        stop_coverage
-      end
-
-      def sample
-        configure_sampling
-        record_coverage
-        result = yield
-        report_coverage
-        result
-      end
-
-      def save
-        @enabled = true
-        report_coverage
-        @enabled = false
-      end
-
-      def reset_instance
-        @project_directory = File.expand_path(Coverband.configuration.root)
-        @enabled = false
-        @disable_on_failure_for = Coverband.configuration.disable_on_failure_for
-        @file_line_usage = {}
-        @ignored_files = Set.new
-        @startup_delay = Coverband.configuration.startup_delay
-        @ignore_patterns = Coverband.configuration.ignore + ['internal:prelude', 'schema.rb']
-        @ignore_patterns += ['gems'] unless Coverband.configuration.include_gems
-        @sample_percentage = Coverband.configuration.percentage
-        @store = Coverband.configuration.store
-        @store = Coverband::Adapters::MemoryCacheStore.new(@store) if Coverband.configuration.memory_caching
-        @verbose  = Coverband.configuration.verbose
-        @logger   = Coverband.configuration.logger
-        @current_thread = Thread.current
-        Thread.current[:coverband_instance] = nil
-        self
-      end
-
-      def configure_sampling
-        if @startup_delay != 0 || (rand * 100.0) > @sample_percentage
-          @startup_delay -= 1 if @startup_delay > 0
-          @enabled = false
-        else
-          @enabled = true
-        end
-      end
-
-      def record_coverage
-        raise 'abstract'
-      end
-
-      def stop_coverage
-        raise 'abstract'
-      end
-
-      def report_coverage
-        raise 'abstract'
-      end
-
-      protected
-
-      def track_file?(file)
-        @ignore_patterns.none? { |pattern| file.include?(pattern) } && file.start_with?(@project_directory)
-      end
-
-      def output_file_line_usage
-        @logger.debug 'coverband debug coverband file:line usage:'
-        @file_line_usage.sort_by { |_key, value| value.length }.each do |pair|
-          file = pair.first
-          lines = pair.last
-          @logger.info "file: #{file} => #{lines.sort_by { |_key, value| value }}"
-        end
-      end
-
-      private
-
-      def failed_at_thread_key
-        "__#{self.class.name}__failed_at"
-      end
-
-      def failed_at
-        Thread.current[failed_at_thread_key]
-      end
-
-      def failed_at=(time)
-        Thread.current[failed_at_thread_key] = time
-      end
-
-      def failed!
-        self.failed_at = Time.now
-      end
-
-      def failed_recently?
-        return false unless @disable_on_failure_for && failed_at
-        failed_at + @disable_on_failure_for > Time.now
-      end
-
-      def initialize
-        reset_instance
-      end
-    end
-  end
-end

data/lib/coverband/collectors/trace.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-module Coverband
-  module Collectors
-    ###
-    # NOTE: While this still works it is slower than Coverage.
-    # I recommend using the Coverage adapter.
-    # As baseline is removed the Trace collector also doesn't have a good way
-    # to collect initial code usage during app boot up.
-    #
-    # I am leaving Trace around as I believe there are some interesting use cases
-    # also, it illustrates an alternative collector, and I have some others I would like to implement
-    ###
-    class Trace < Base
-      def reset_instance
-        super
-        @tracer_set = false
-        @trace_point_events = [:line]
-        @trace = create_trace_point
-        self
-      end
-
-      def record_coverage
-        if @enabled && !failed_recently?
-          set_tracer
-        else
-          unset_tracer
-        end
-      rescue RuntimeError => err
-        failed!
-        if @verbose
-          @logger.error 'error stating recording coverage'
-          @logger.error "error: #{err.inspect} #{err.message}"
-          @logger.error err.backtrace
-        end
-      end
-
-      def stop_coverage
-        unset_tracer
-      end
-
-      def report_coverage
-        unless @enabled
-          @logger.info 'coverage disabled' if @verbose
-          return
-        end
-
-        unset_tracer
-
-        if failed_recently?
-          @logger.error 'coverage reporting standing-by because of recent failure' if @verbose
-          return
-        end
-
-        if @verbose
-          @logger.debug "coverband file usage: #{file_usage.inspect}"
-          output_file_line_usage if @verbose == 'debug'
-        end
-
-        if @store
-          @store.save_report(@file_line_usage)
-          @file_line_usage.clear
-        elsif @verbose
-          @logger.info 'coverage report: '
-          @logger.info @file_line_usage.inspect
-        end
-      rescue RuntimeError => err
-        failed!
-        if @verbose
-          @logger.error 'coverage missing'
-          @logger.error "error: #{err.inspect} #{err.message}"
-          @logger.error err.backtrace
-        end
-      end
-
-      protected
-
-      def set_tracer
-        unless @tracer_set
-          @trace.enable
-          @tracer_set = true
-        end
-      end
-
-      def unset_tracer
-        @trace.disable
-        @tracer_set = false
-      end
-
-      private
-
-      def add_file(file, line)
-        @file_line_usage[file] = Hash.new(0) unless @file_line_usage.include?(file)
-        @file_line_usage[file][line] += 1
-      end
-
-      def file_usage
-        hash = {}
-        @file_line_usage.each do |file, lines|
-          hash[file] = lines.values.inject(0, :+)
-        end
-        hash.sort_by { |_key, value| value }
-      end
-
-      def create_trace_point
-        TracePoint.new(*@trace_point_events) do |tp|
-          if Thread.current == @current_thread
-            file = tp.path
-
-            unless @ignored_files.include?(file)
-              if track_file?(file)
-                add_file(file, tp.lineno)
-              else
-                @ignored_files << file
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/coverband/s3_report_writer.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-# possibly move to / make an adapter or more likely a reporter
-class S3ReportWriter
-  def initialize(bucket_name, options = {})
-    @bucket_name = bucket_name
-    @region = options[:region]
-    @access_key_id = options[:access_key_id]
-    @secret_access_key = options[:secret_access_key]
-    begin
-      require 'aws-sdk'
-    rescue StandardError
-      Coverband.configuration.logger.error "coverband requires 'aws-sdk' in order use S3ReportWriter."
-      return
-    end
-  end
-
-  def persist!
-    object.put(body: coverage_content)
-  end
-
-  private
-
-  def coverage_content
-    version = Gem::Specification.find_by_name('simplecov-html').version.version
-    File.read("#{SimpleCov.coverage_dir}/index.html").gsub("./assets/#{version}/", '')
-  rescue StandardError
-    File.read("#{SimpleCov.coverage_dir}/index.html").to_s.gsub('./assets/0.10.1/', '')
-  end
-
-  def object
-    bucket.object('coverband/index.html')
-  end
-
-  def s3
-    client_options = {
-      region: @region,
-      access_key_id: @access_key_id,
-      secret_access_key: @secret_access_key
-    }
-    resource_options = { client: Aws::S3::Client.new(client_options) }
-    resource_options = {} if client_options.values.any?(&:nil?)
-    Aws::S3::Resource.new(resource_options)
-  end
-
-  def bucket
-    s3.bucket(@bucket_name)
-  end
-end

data/test/unit/adapters_memory_cache_store_test.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path('../test_helper', File.dirname(__FILE__))
-
-module Coverband
-  class MemoryCacheStoreTest < Test::Unit::TestCase
-    def setup
-      Adapters::MemoryCacheStore.clear!
-      @redis = Redis.new
-      @store = Coverband::Adapters::RedisStore.new(@redis)
-      @store.clear!
-      @memory_store = Adapters::MemoryCacheStore.new(@store)
-    end
-
-    test 'it passes data into store' do
-      data = {
-        'file1' => { 1 => 0, 2 => 1, 3 => 0 },
-        'file2' => { 1 => 5, 2 => 2 }
-      }
-      @store.expects(:save_report).with data
-      @memory_store.save_report data
-    end
-
-
-    test 'it filters coverage with same exact data' do
-      data = {
-        'file1' => { 1 => 0, 2 => 1, 3 => 0 },
-        'file2' => { 1 => 5, 2 => 2 }
-      }
-      @store.expects(:save_report).once.with data
-      2.times { @memory_store.save_report data }
-    end
-    
-    test 'it filters coverage for files with same exact data' do
- 
-      report_first_request = {
-        'file1' => { 1 => 0, 2 => 1, 3 => 0 },
-        'file2' => { 1 => 5, 2 => 2 }
-      }
-
-      report_second_request = {
-        'file1' => { 1 => 0, 2 => 1, 3 => 0 },
-        'file2' => { 1 => 5, 2 => 3 }
-      }
-      @store.expects(:save_report).with({
-        'file1' => { 1 => 0, 2 => 1, 3 => 0 },
-        'file2' => { 1 => 5, 2 => 2 }
-      })
-      @store.expects(:save_report).with({
-        'file2' => { 1 => 5, 2 => 3 }
-      })
-      @memory_store.save_report(report_first_request)
-      @memory_store.save_report(report_second_request)
-    end
-
-    test 'it initializes cache with what is in store' do
-      data = {
-        'file1' => { 1 => 0, 2 => 1, 3 => 0 },
-        'file2' => { 1 => 5, 2 => 2 }
-      }
-      Coverband::Adapters::RedisStore.new(@redis).save_report(data)
-      @store.expects(:save_report).never
-      @memory_store.save_report(data)
-    end
-  end
-end

data/test/unit/collectors_base_test.rb

@@ -1,104 +0,0 @@
-# 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
-  def setup
-    Coverband.configure do |config|
-      config.collector         = 'trace'
-    end
-  end
-
-  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')
-  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
-    logger.stubs('debug')
-    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
-    logger.stubs('debug')
-    coverband.start
-    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')
-    Coverband.configuration.logger.stubs('debug')
-    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 }
-    Coverband::Collectors::Base.instance
-    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